Algorithm Learning Guide

šŸ“‹ Topic list
Next Complexity Analysis

Algorithm Learning Guide

Introduction

This folder contains materials for systematically learning algorithms and data structures. You can study step-by-step from complexity analysis to advanced algorithms, which is helpful for coding interview preparation and algorithm competition training.

Target Audience: Developers with programming fundamentals, coding test preparation candidates

Learning Roadmap

[Basic]                   [Intermediate]            [Advanced]
  ā”‚                         ā”‚                         ā”‚
  ā–¼                         ā–¼                         ā–¼
Complexity Analysis ā”€ā”€ā”€ā–¶ Divide & Conquer ā”€ā”€ā”€ā–¶ Dynamic Programming
  ā”‚                    ā”‚                      ā”‚
  ā–¼                    ā–¼                      ā–¼
Arrays/Strings ā”€ā”€ā”€ā”€ā”€ā–¶ Trees/BST ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā–¶ Segment Tree
  ā”‚                    ā”‚                      ā”‚
  ā–¼                    ā–¼                      ā–¼
Stacks/Queues ā”€ā”€ā”€ā”€ā”€ā”€ā–¶ Graph Basics ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā–¶ Network Flow
  ā”‚                    ā”‚                      ā”‚
  ā–¼                    ā–¼                      ā–¼
Hash Tables ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā”€ā–¶ Shortest Path/MST ā”€ā”€ā–¶ Advanced DP Optimization

Prerequisites

  • Programming fundamentals (variables, control flow, functions)
  • Basic data structures (arrays, lists)
  • At least one language among C, C++, or Python

File List

Basic Data Structures (01-05)

Filename Difficulty Key Topics
01_Complexity_Analysis.md ā­ Big O, time/space complexity, analysis techniques
02_Arrays_and_Strings.md ā­ Two pointers, sliding window, prefix sum
03_Stacks_and_Queues.md ā­ Parenthesis checking, postfix notation, monotonic stack
04_Hash_Tables.md ā­ā­ Hash functions, collision resolution, hashmap/set implementation
05_Sorting_Algorithms.md ā­ā­ Bubble/selection/insertion/merge/quick/heap sort

Search and Divide & Conquer (06-08)

Filename Difficulty Key Topics
06_Searching_Algorithms.md ā­ā­ Binary search, parametric search, hash search
07_Divide_and_Conquer.md ā­ā­ Merge sort, quick sort, fast exponentiation
08_Backtracking.md ā­ā­ā­ N-Queens, permutations/combinations, pruning

Tree Data Structures (09-11)

Filename Difficulty Key Topics
09_Trees_and_BST.md ā­ā­ Tree traversal, BST operations, balanced trees
10_Heaps_and_Priority_Queues.md ā­ā­ Heap structure, heap sort, kth element
11_Trie.md ā­ā­ā­ Prefix tree, autocomplete, XOR trie

Graphs (12-17)

Filename Difficulty Key Topics
12_Graph_Basics.md ā­ā­ Graph representation, DFS, BFS
13_Topological_Sort.md ā­ā­ā­ Kahn, DFS-based, cycle detection
14_Shortest_Path.md ā­ā­ā­ Dijkstra, Bellman-Ford, Floyd-Warshall
15_Minimum_Spanning_Tree.md ā­ā­ā­ Kruskal, Prim, Union-Find
16_LCA_and_Tree_Queries.md ā­ā­ā­ Binary Lifting, Sparse Table
17_Strongly_Connected_Components.md ā­ā­ā­ā­ Tarjan, Kosaraju, 2-SAT

DP and Mathematics (18-22)

Filename Difficulty Key Topics
18_Dynamic_Programming.md ā­ā­ā­ Memoization, knapsack, LCS, LIS
19_Greedy_Algorithms.md ā­ā­ Activity selection, Huffman coding, greedy vs DP
20_Bitmask_DP.md ā­ā­ā­ Bit operations, TSP, set DP
21_Math_and_Number_Theory.md ā­ā­ā­ Modular arithmetic, GCD/LCM, primes, combinatorics
22_String_Algorithms.md ā­ā­ā­ KMP, Rabin-Karp, Z-algorithm

Advanced Data Structures (23-24)

Filename Difficulty Key Topics
23_Segment_Tree.md ā­ā­ā­ā­ Range queries, Lazy Propagation
24_Fenwick_Tree.md ā­ā­ā­ BIT, range sum, 2D Fenwick

Advanced Graphs (25)

Filename Difficulty Key Topics
25_Network_Flow.md ā­ā­ā­ā­ Ford-Fulkerson, bipartite matching

Special Topics (26-28)

Filename Difficulty Key Topics
26_Computational_Geometry.md ā­ā­ā­ CCW, convex hull, line segment intersection
27_Game_Theory.md ā­ā­ā­ Nim game, Sprague-Grundy, minimax
28_Advanced_DP_Optimization.md ā­ā­ā­ā­ CHT, D&C optimization, Knuth optimization

Wrap-up

Filename Difficulty Key Topics
29_Problem_Solving.md ā­ā­ā­ā­ Problem type approaches, LeetCode/BOJ recommendations

Phase 1: Basic Data Structures (1 week)

01 ā†’ 02 ā†’ 03 ā†’ 04

Phase 2: Sorting and Searching (1 week)

05 ā†’ 06 ā†’ 07 ā†’ 08

Phase 3: Trees (1 week)

09 ā†’ 10 ā†’ 11

Phase 4: Graph Basics (1-2 weeks)

12 ā†’ 13 ā†’ 14 ā†’ 15

Phase 5: Advanced Graphs (1 week)

16 ā†’ 17

Phase 6: DP and Mathematics (2 weeks)

18 ā†’ 19 ā†’ 20 ā†’ 21 ā†’ 22

Phase 7: Advanced Data Structures (1 week)

23 ā†’ 24

Phase 8: Advanced Graphs and Special Topics (2+ weeks)

25 ā†’ 26 ā†’ 27 ā†’ 28

Wrap-up

29 (recommended to proceed in parallel with other phases)

Practice Environment

Language-specific Setup

# C/C++ (GCC)
gcc --version
g++ --version

# Python
python3 --version

# Online environments
# - https://www.onlinegdb.com/
# - https://replit.com/
  • IDE: VS Code, CLion, PyCharm
  • Online Judge: BOJ (Baekjoon), LeetCode, Programmers
  • Visualization: https://visualgo.net/

Complexity Quick Reference

Complexity Name Example ~10^6 operations
O(1) Constant Array access Instant
O(log n) Logarithmic Binary search ~20 ops
O(n) Linear Sequential search 10^6 ops
O(n log n) Linearithmic Merge sort ~2Ɨ10^7 ops
O(nĀ²) Quadratic Bubble sort 10^12 ops (caution)
O(2^n) Exponential Subsets Infeasible

Integration with Other Folders

Folder Related Content
C_Programming/ Dynamic arrays, linked lists, hash table implementation
CPP/ STL containers, algorithm header usage
Python/ List comprehension, itertools usage

External Resources

Learning Tips

  1. Implement Yourself: Try implementing before using libraries
  2. Complexity Analysis: Calculate time/space complexity for all code
  3. Multiple Languages: Implement the same algorithm in C, C++, and Python
  4. Problem Solving: Solve 3-5 related problems after each lesson
  5. Error Log: Record why you got problems wrong

Coding Test Preparation Guide

Goals by Level

Level Goal Required Lessons
Beginner Solve basic problems 01~08
Intermediate Major company coding tests 01~17
Advanced Algorithm competitions 01~25
Expert ICPC/IOI level All (including 26~29)

Time Limit Guidelines

  • 1 second: O(n log n) or better (n ā‰¤ 10^6)
  • 2 seconds: O(nĀ²) feasible (n ā‰¤ 5000)
  • 5 seconds: O(nĀ²) feasible (n ā‰¤ 10000)
šŸ“‹ Topic list
Next Complexity Analysis
← → to navigate between lessons