pacifio / dsa4e

Data structures for everybody is a collection of code written to understand and practice common algorithms we use day to day during our lives, how we append the list, how languages sort items efficiently, we will try to understand it all.

Data structures for everybody

Data structures for everybody is a collection of code written to understand and practice common algorithms we use day to day during our lives, how we append the list, how languages sort items efficiently, we will try to understand it all.

Data Structures:

1. Arrays: Static and dynamic arrays, operations like insertion, deletion, and searching. ✅
2. Linked Lists: Singly linked lists, doubly linked lists, circular linked lists.
3. Stacks: Basic operations (push, pop), and their applications (e.g., implementing function calls).
4. Queues: Basic operations (enqueue, dequeue), and different implementations (e.g., priority queue, double-ended queue).
5. Hash Tables: Understanding hashing, collision resolution techniques (e.g., chaining, open addressing).
6. Trees: Binary trees, binary search trees (BST), AVL trees, and other self-balancing trees.
7. Heaps: Min-heap, max-heap, and their applications (e.g., heap sort).
8. Graphs: Basics of graph representation (adjacency matrix, adjacency list), traversal algorithms (DFS, BFS).
9. Trie: Trie data structure for efficient string search and manipulation.

Algorithms:

1. Sorting Algorithms:

   • Bubble Sort
   • Selection Sort
   • Insertion Sort
   • Merge Sort
   • Quick Sort
   • Radix Sort
   • Heap Sort

2. Searching Algorithms:

   • Linear Search
   • Binary Search
   • Hashing (using hash tables)

3. Graph Algorithms:

   • Depth-First Search (DFS)
   • Breadth-First Search (BFS)
   • Dijkstra's Algorithm (for single-source shortest paths)
   • Bellman-Ford Algorithm (for single-source shortest paths with negative weights)
   • Kruskal's Algorithm (for minimum spanning trees)
   • Prim's Algorithm (for minimum spanning trees)

4. Dynamic Programming:

   • Fibonacci Series
   • Longest Common Subsequence (LCS)
   • Knapsack Problem
   • Matrix Chain Multiplication
   • Edit Distance
   • Dynamic programming for graph problems (e.g., Floyd-Warshall for all-pairs shortest paths)

5. Greedy Algorithms:

   • Minimum Spanning Tree Algorithms (e.g., Prim's, Kruskal's)
   • Huffman Coding
   • Dijkstra's Algorithm for Shortest Paths

6. Divide and Conquer Algorithms:

   • Merge Sort
   • Quick Sort
   • Karatsuba Multiplication

7. Backtracking Algorithms:

   • N-Queens Problem
   • Sudoku Solver
   • Traveling Salesman Problem (TSP)

8. String Matching Algorithms:

   • Brute Force
   • Knuth-Morris-Pratt (KMP)
   • Boyer-Moore

9. Advanced Data Structures and Algorithms:

   • Red-Black Trees
   • B-Trees
   • Trie variants (e.g., Ternary Search Trie)
   • Skip Lists
   • Segment Trees
   • Fenwick Trees (Binary Indexed Trees)
   • Disjoint Set (Union-Find) Data Structure

10. Algorithmic Paradigms:

    • Divide and Conquer
    • Greedy Algorithms
    • Dynamic Programming
    • Backtracking
    • Randomised Algorithms
    • Approximation Algorithms