⚠️ The source code in this repository doesn't contain ready-to-use code. Though, I've written some tests and benchmarks, and even though some of them are quite extensive, I haven't spent too much time on optimizations and general usages(exception handling, generic interfaces etc.), not to mention code styles.

Data Structures

• Queues:
  • Array based Queue (code, tests)
  • Circular Queue (code, tests)
  • Linked List based Queue (code, tests)
  • Binary Queue based Priority Queue (code)
• Stacks:
  • Array based Stack (code, tests)
  • Linked List Stack (code, tests)
  • Queue based Stack (code, tests)
• Unrolled Linked List (code, tests)
• Linked Lists:
  • Singly Linked List (code, tests)
  • Doubly Linked List (code, tests)
  • Singly Circular Linked List (code, tests)
  • Skip List (code, tests)
• Self-organizing Lists:
  • Count based Self-organizing List (code, tests)
  • Move to forward Self-organizing List (code, tests)
  • Transpose Self-organizing List (code, tests)
• Hash Tables:
  • Separate chaining (code, tests)
  • Open address hasing (code, tests)
• Graphs:
  • Adjacency matrix representation (code)
  • Adjacency list representation (code, tests)
• Binary Trees:
  • Binary Tree (code, tests)
  • Array Binary Tree (code, tests)
• Binary Search Tree (code, tests)
• Binary Indexed Tree (code, tests)
• Binary Heaps:
  • Binary Heap (code)
  • Max Binary Heap (code, tests)
  • Min Binary Heap (code, tests)
• AVL Tree (code, tests)
• Red-Black Tree (code, tests)
• Segment Trees:
  • Abstract Segment Tree (code)
  • Min Segment Tree (code, tests)
  • Sum Segment Tree (code, tests)
• Tries:
  • Trie(Alphabet Trie) (code, tests)
  • Ternary Trie (code, tests)
• Suffix Arrays:
  • Naive (code, tests)
  • n*logN (code, tests)
• Decision Trees:
  • ID3 (code, tests)
• Disjoin Sets:
  • Greedy Disjoin Set (code, tests)
  • Tree Disjoin Set (code, tests)
  • Weighted Tree Disjoin Set (code, tests)
  • Weighted Tree Disjoin Set with Compressed Path (code, tests)
• State Machines:
  • Simplest Finite State Machine (code)
  • Stack State Machine (code)
• Caches:
  • LFU (code, tests)
  • LFU(min heap based) (code, tests)
  • LRU (code, tests)
• Buckets:
  • Simple token bucket (code, tests)
  • Simple leaky bucket (code, tests)

Algorithms

• Compression:
  • Huffman Code (code, tests)
  • LZW - Huffman Code (code, tests)
• Cryptography:
  • Cesar Cipher (code, tests)
  • One Time Pad (code, tests)
• Dynamic Programming:
  • Digit DP (code, tests)
  • 0/1 Knapsack (code, tests)
  • Undounded Knapsack (code, tests)
  • Fibonacci numbers Knapsack (code, tests)
  • Change making (code, tests)
  • Unique Change making (code, tests)
  • Longest Common Subsequence (code, tests)
  • Wine cellar (code, tests)
  • Caps assignment (code, tests)
  • Represent N as sum of 1,3,4 (code, tests)
• Graphs:
  • Backtracking:
    • Path of more than K length (code, tests)
    • Hamilton's path (code, tests)
    • m-coloring Problem (code, tests)
  • Coloring:
    • Greedy (code, tests)
  • K-Centers:
    • Greedy (code, tests)
  • Longest Path:
    • Critical Path (code, tests)
    • Longest Path In a DAG (code, tests)
  • Maximum Flow and Bipartite matching:
    • Dinic's algorithm (code, tests)
    • Edge-Disjoint Path (code, tests)
    • Ford-Fulkerson (code, tests)
    • Ford-Fulkerson With Capacity Heuristic (code, tests)
    • Hopcroft-Karp (code, tests)
    • Maximum Bipartite Matching DFS-Based (code, tests)
    • Maximum Bipartite Matching Ford-Fulkerson-Based (code, tests)
    • Push-relabel (code, tests)
  • Min Cut:
    • ST-Cut Ford-Fulkerson based (code, tests)
    • ST-Cut naive (code, tests)
    • Karger's algorithm (code, tests)
  • Minimum Spanning Tree:
    • Boruvka's algorithm (code, tests)
    • Kruskal's algorithm (code, tests)
    • Kruskal's algorithm with disjoint set (code, tests)
    • Prim's algorithm (code, tests)
  • Search:
    • Breadth-First-Search (code, tests)
    • Depth-First-Search (code, tests)
  • Shortest path:
    • Bellman-Ford Algorithm (code, tests)
    • Dijkstra's Algorithm with heap (code, tests)
    • Dijkstra's Algorithm naive (code, tests)
    • Floyd-Warshall (code, tests)
  • Traveling Salesman
    • Naive (code, tests)
    • Greedy (code, tests)
    • Min Spanning Tree (code, tests)
    • Dynamic Programming (code, tests)
  • Vertex Cover:
    • Simple Approximation (code, tests)
  • Voting:
    • Schulze Method (code, tests)
  • Misc:
    • Biconnected Graph check using Tarjan's Algorithm (code, tests)
    • Bipartite Graph check using DFS (code, tests)
    • Bipartite Graph check using BFS (code, tests)
    • Bridges in Graph check using Tarjan's Algorithm (code, tests)
    • Cycles in Graph check using DFS (code, tests)
    • Eulerian Path (code, tests)
    • Fleury's algorithm (code, tests)
    • Kosaraju's Algorithm (code, tests)
    • Negative Cycle Detection using Bellman-Ford (code, tests)
    • Tarjan's Algorithm (code, tests)
    • Biconnected Components using Tarjan's algorithm (code, tests)
    • Topological Sort (code, tests)
    • Transitive Closure using Floyd-Warshall algorithm (code, tests)
• Hashing:
  • Alder32 (code)
  • FowlerNollVo1aBasedHash (code, tests)
• Numbers:
  • Euclidian Common Denominator (code, tests)
  • Sieve of Eratosthenes (code, tests)
• Pseudorandom Number Generators:
  • Linear Congruential Random Number Generator (code)
  • XOR Shift 1024 Star (code)
  • XOR Shift 64 Star (code)
• Sampling:
  • Reservoir Sampling (code, tests)
  • Selection Sampling (code, tests)
• Search:
  • Binary Search Recursive (code, tests)
  • Binary Search (code, tests)
  • Exponential Search (code, tests)
  • Fibonacci Search (code, tests)
  • Interpolation Search (code, tests)
  • Jump Search (code, tests)
  • Linear Search (code, tests)
  • Quick Select (code, tests)
  • Sublist (code, tests)
• Sorting:
  • Bubble Sort (code, tests)
  • Comb Sort (code, tests)
  • Count Sort (code, tests)
  • Heap Sort (code, tests)
  • Insertion Sort (code, tests)
  • Merge Sort (code, tests)
  • Partitioned Merge Sort (code, tests)
  • Quick Sort (code, tests)
  • Quick Sort(Lomuto's partition) (code, tests)
  • Radix Sort (code, tests)
  • Selection Sort (code, tests)
  • Shell Sort (code, tests)
• Strings:
  • Levenstine Distance (code, tests)
  • Booyer-Moore Combined Heuristic (code, tests)
  • Booyer-Moore Bad Character Heuristic (code, tests)
  • Booyer-Moore Good Suffix Heuristic (code, tests)
  • Knuth-Morris-Pratt (code, tests)
  • Naive pattern Search (code, tests)
  • Recursive pattern Search (code, tests)
  • Rabin-Karp (code, tests)
  • Least Significant Digit sorting (code, tests)
  • Most Significant Digit sorting (code, tests)
• Bitwise stuff: (code, tests

Misc concurrent problems

• Asynchronous to Synchronous (code, tests)
• Dining Philosophers (code, tests)
• Reader Writer Lock (code)
• Simple Barrier (code, tests)
• Simple Blocking Queue (code, tests)
• Simple Non Blocking Queue (code, tests)
• Sleeping Barber (code)
• Uber Ride (code, tests)
• Unisex Bathroom (code)