{"id":262,"date":"2025-03-03T15:14:52","date_gmt":"2025-03-03T13:14:52","guid":{"rendered":"https:\/\/codeblog.xyz\/?p=262"},"modified":"2025-03-03T15:14:52","modified_gmt":"2025-03-03T13:14:52","slug":"30-fundamental-algorithms","status":"publish","type":"post","link":"https:\/\/codeblog.xyz\/?p=262","title":{"rendered":"30 Fundamental Algorithms"},"content":{"rendered":"\n

<\/p>\n\n\n\n

1. Sorting Algorithms (Essential for Interviews)<\/strong><\/h3>\n\n\n\n
    \n
  1. Bubble Sort<\/a><\/strong> – Basic sorting algorithm, inefficient for large data.<\/li>\n\n\n\n
  2. Selection Sort<\/a><\/strong> – Selects the smallest element and places it in order.<\/li>\n\n\n\n
  3. Insertion Sort<\/a><\/strong> – Inserts elements into their correct position.<\/li>\n\n\n\n
  4. Merge Sort<\/a><\/strong> – Efficient, divide-and-conquer sorting with O(n log n)<\/strong> complexity.<\/li>\n\n\n\n
  5. Quick Sort<\/a><\/strong> – Fast sorting using partitioning, average O(n log n)<\/strong> complexity.<\/li>\n\n\n\n
  6. Heap Sort<\/strong> <\/a>– Sorting using a heap, used in priority queues<\/strong>.<\/li>\n\n\n\n
  7. Counting Sort<\/a><\/strong> – Good for small range of numbers.<\/li>\n\n\n\n
  8. Radix Sort<\/a><\/strong> – Used for sorting numbers with multiple digits efficiently.<\/li>\n<\/ol>\n\n\n\n

    2. Searching Algorithms<\/strong><\/h3>\n\n\n\n
      \n
    1. Linear Search<\/a><\/strong> – Basic search, used in unsorted lists.<\/li>\n\n\n\n
    2. Binary Search<\/a><\/strong> – Fast O(log n)<\/strong> search, works only in sorted arrays<\/strong>.<\/li>\n\n\n\n
    3. Jump Search<\/a><\/strong> – Faster than binary search for sorted data.<\/li>\n\n\n\n
    4. Exponential Search<\/a><\/strong> – Good for unbounded lists.<\/li>\n\n\n\n
    5. Interpolation Search<\/a><\/strong> – Faster than binary search for uniformly distributed data.<\/li>\n<\/ol>\n\n\n\n

      3. Graph Algorithms<\/strong><\/h3>\n\n\n\n
        \n
      1. Breadth-First Search (BFS)<\/a><\/strong> – Traverses level-by-level, used in shortest path problems.<\/li>\n\n\n\n
      2. Depth-First Search (DFS)<\/a><\/strong> – Explores depth before breadth, used in tree\/graph traversal.<\/li>\n\n\n\n
      3. Dijkstra\u2019s Algorithm<\/a><\/strong> – Finds the shortest path from a source node (greedy approach).<\/li>\n\n\n\n
      4. Bellman-Ford Algorithm<\/a><\/strong> – Shortest path with negative weights.<\/li>\n\n\n\n
      5. Floyd-Warshall Algorithm<\/a><\/strong> – All-pairs shortest paths.<\/li>\n\n\n\n
      6. Kruskal\u2019s Algorithm<\/a><\/strong> – Finds Minimum Spanning Tree (MST)<\/strong> using greedy approach<\/strong>.<\/li>\n\n\n\n
      7. Prim\u2019s Algorithm<\/a><\/strong> – Another approach for MST<\/strong>.<\/li>\n\n\n\n
      8. Topological Sorting<\/a><\/strong> – Used in DAGs<\/strong> (Directed Acyclic Graphs) like dependency resolution.<\/li>\n<\/ol>\n\n\n\n

        4. Tree Algorithms<\/strong><\/h3>\n\n\n\n
          \n
        1. Binary Tree Traversal (Inorder, Preorder, Postorder, Level Order BFS)<\/a><\/strong><\/li>\n\n\n\n
        2. Lowest Common Ancestor (LCA)<\/a><\/strong> – Finds the common ancestor of two nodes.<\/li>\n\n\n\n
        3. Morris Traversal<\/a><\/strong> – In-order traversal without recursion or stack.<\/li>\n\n\n\n
        4. Trie (Prefix Tree)<\/a><\/strong> – Used for searching strings efficiently (autocomplete systems).<\/li>\n<\/ol>\n\n\n\n

          5. Dynamic Programming & Recursion<\/strong><\/h3>\n\n\n\n
            \n
          1. Fibonacci Series (DP & Recursion)<\/a><\/strong> – Classic problem for understanding memoization.<\/li>\n\n\n\n
          2. Knapsack Problem (0\/1 Knapsack & Fractional Knapsack)<\/a><\/strong> – Optimization problem.<\/li>\n\n\n\n
          3. Longest Common Subsequence (LCS)<\/a><\/strong> – Used in diff utilities, DNA sequencing<\/strong>.<\/li>\n\n\n\n
          4. Coin Change Problem<\/a><\/strong> – Find the minimum number of coins needed for a sum.<\/li>\n\n\n\n
          5. Subset Sum Problem<\/a><\/strong> – Determines if a subset sums to a given value.<\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"

            1. Sorting Algorithms (Essential for Interviews) 2. Searching Algorithms 3. Graph Algorithms 4. Tree Algorithms 5. Dynamic Programming & Recursion<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-262","post","type-post","status-publish","format-standard","hentry","category-blog"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/codeblog.xyz\/index.php?rest_route=\/wp\/v2\/posts\/262","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/codeblog.xyz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/codeblog.xyz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/codeblog.xyz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/codeblog.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=262"}],"version-history":[{"count":2,"href":"https:\/\/codeblog.xyz\/index.php?rest_route=\/wp\/v2\/posts\/262\/revisions"}],"predecessor-version":[{"id":264,"href":"https:\/\/codeblog.xyz\/index.php?rest_route=\/wp\/v2\/posts\/262\/revisions\/264"}],"wp:attachment":[{"href":"https:\/\/codeblog.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=262"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/codeblog.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=262"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/codeblog.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=262"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}