👋 Giới thiệu

Nhiều người mới học lập trình thường hỏi: “Học giải thuật để làm gì, trong khi công việc hàng ngày chỉ cần gọi API, viết CRUD?” Câu trả lời nằm ở chỗ giải thuật không phải một môn học tách biệt, mà là cách tư duy để giải quyết vấn đề hiệu quả - và cấu trúc dữ liệu chính là “hình dạng” mà bạn tổ chức thông tin để giải thuật vận hành trơn tru trên đó.

Bạn có thể nhìn thấy cấu trúc dữ liệu ở khắp nơi trong đời sống, không chỉ trong code: một chồng đĩa trong bếp hoạt động như ngăn xếp (stack) - đĩa đặt lên sau cùng được lấy ra trước; hàng người xếp hàng mua vé hoạt động như hàng đợi (queue) - ai đến trước được phục vụ trước; sơ đồ phả hệ gia đình hay cây thư mục trên máy tính chính là một cây (tree); bản đồ tuyến xe buýt hay mạng lưới bạn bè trên mạng xã hội có thể mô hình hóa bằng đồ thị (graph); còn mục lục cuối một cuốn sách, cho phép bạn tra một từ khóa và nhảy thẳng đến trang chứa nó, hoạt động giống hệt một bảng băm (hash table).

DSA là gì?

Cấu trúc dữ liệu (Data Structures) là cách tổ chức và lưu trữ dữ liệu trong máy tính sao cho có thể truy cập và sử dụng hiệu quả.

Giải thuật (Algorithms) là một tập hợp các bước có thứ tự để giải quyết một vấn đề cụ thể.

Tại sao cần học DSA?

1. Viết code hiệu quả hơn

Ví dụ tìm phần tử trùng lặp - so sánh O(n²) vs O(n):

# Cách không tối ưu - O(n²)
def find_duplicate_slow(arr):
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            if arr[i] == arr[j]:
                return arr[i]
    return None

# Cách tối ưu với Set - O(n)
def find_duplicate_fast(arr):
    seen = set()
    for num in arr:
        if num in seen:
            return num
        seen.add(num)
    return None

// Cách không tối ưu - O(n²)
fun findDuplicateSlow(arr: List<Int>): Int? {
    for (i in arr.indices) {
        for (j in i + 1 until arr.size) {
            if (arr[i] == arr[j]) return arr[i]
        }
    }
    return null
}

// Cách tối ưu với Set - O(n)
fun findDuplicateFast(arr: List<Int>): Int? {
    val seen = mutableSetOf<Int>()
    for (num in arr) {
        if (num in seen) return num
        seen.add(num)
    }
    return null
}

// Cách không tối ưu - O(n²)
int? findDuplicateSlow(List<int> arr) {
  for (int i = 0; i < arr.length; i++) {
    for (int j = i + 1; j < arr.length; j++) {
      if (arr[i] == arr[j]) return arr[i];
    }
  }
  return null;
}

// Cách tối ưu với Set - O(n)
int? findDuplicateFast(List<int> arr) {
  Set<int> seen = {};
  for (int num in arr) {
    if (seen.contains(num)) return num;
    seen.add(num);
  }
  return null;
}

// Cách không tối ưu - O(n²)
func findDuplicateSlow(_ arr: [Int]) -> Int? {
    for i in 0..<arr.count {
        for j in (i + 1)..<arr.count {
            if arr[i] == arr[j] { return arr[i] }
        }
    }
    return nil
}

// Cách tối ưu với Set - O(n)
func findDuplicateFast(_ arr: [Int]) -> Int? {
    var seen = Set<Int>()
    for num in arr {
        if seen.contains(num) { return num }
        seen.insert(num)
    }
    return nil
}

// Cách không tối ưu - O(n²)
public static Integer findDuplicateSlow(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] == arr[j]) return arr[i];
        }
    }
    return null;
}

// Cách tối ưu với Set - O(n)
public static Integer findDuplicateFast(int[] arr) {
    Set<Integer> seen = new HashSet<>();
    for (int num : arr) {
        if (seen.contains(num)) return num;
        seen.add(num);
    }
    return null;
}

2. Giải quyết vấn đề phức tạp

DSA cung cấp các mẫu (patterns) đã được chứng minh để giải quyết nhiều loại bài toán: tìm đường đi ngắn nhất, sắp xếp dữ liệu, tìm kiếm nhanh, tối ưu hóa…

3. Phỏng vấn kỹ thuật

Hầu hết các công ty công nghệ lớn (Google, Facebook, Amazon…) đều yêu cầu DSA trong phỏng vấn.

Các cấu trúc dữ liệu cơ bản

Cấu trúc	Mô tả	Ví dụ thực tế
Array	Danh sách có thứ tự, truy cập theo index	Danh sách học sinh
Linked List	Các node liên kết với nhau	Playlist nhạc
Stack	LIFO - Vào sau, ra trước	Nút Undo/Redo
Queue	FIFO - Vào trước, ra trước	Hàng đợi mua vé
Hash Table	Lưu trữ key-value	Từ điển
Tree	Cấu trúc phân cấp	Thư mục file
Graph	Các đỉnh kết nối bởi cạnh	Mạng xã hội

Các thuật toán quan trọng

Thuật toán	Mục đích
Binary Search	Tìm kiếm nhanh trong mảng đã sắp xếp
Merge Sort	Sắp xếp hiệu quả O(n log n)
BFS/DFS	Duyệt đồ thị
Dynamic Programming	Tối ưu hóa bài toán con lặp lại

Loạt bài này viết cho ai?

Loạt bài này phù hợp nếu bạn:

Mới bắt đầu tìm hiểu cấu trúc dữ liệu và giải thuật, chưa biết nên học từ đâu.
Đã từng giải một số bài tập nhưng cảm thấy kiến thức còn rời rạc, muốn hệ thống lại.
Cần một tài liệu tham khảo nhanh khi ôn tập trước phỏng vấn hoặc khi cần nhớ lại một kỹ thuật cụ thể.

Bạn chỉ cần có nền tảng lập trình cơ bản ở bất kỳ ngôn ngữ nào - biết viết hàm, vòng lặp, điều kiện - là đủ để bắt đầu.

Nội dung

Nội dung được chia thành ba mảng lớn, đi từ nền tảng đến ứng dụng:

Phân tích độ phức tạp - cách đo “chi phí” của một thuật toán về thời gian và bộ nhớ, để so sánh các cách giải khác nhau một cách khách quan thay vì chỉ dựa vào cảm giác “thấy nhanh hơn”.
Cấu trúc dữ liệu - mảng, danh sách liên kết, ngăn xếp, hàng đợi, bảng băm, cây, heap, đồ thị: mỗi loại có điểm mạnh, điểm yếu và tình huống sử dụng riêng.
Giải thuật - tìm kiếm, sắp xếp, chia để trị, quy hoạch động, tham lam, quay lui: những chiến lược giải quyết vấn đề có thể tái sử dụng cho rất nhiều bài toán khác nhau.

Mỗi trang đều có ví dụ code chạy được (chủ yếu bằng Python, kèm một số ngôn ngữ khác) để bạn vừa đọc vừa thực hành, thay vì chỉ học lý thuyết suông.

Bắt đầu từ đâu?

Độ phức tạp thuật toán - Hiểu Big O trước tiên
Mảng (Array) - Cấu trúc dữ liệu cơ bản nhất
Tiếp tục theo lộ trình trong sidebar