算法与数据结构

C++ 是一种高效、灵活的编程语言，广泛应用于算法与数据结构的实现。其特性（如指针、内存管理、模板等）使其成为实现复杂数据结构和算法的理想选择。

常见数据结构

数组（Array）

• 特点：连续内存存储，固定大小，支持随机访问。
• C++ 实现：

int arr[5] = {1, 2, 3, 4, 5};

•  int arr[5] = {1, 2, 3, 4, 5};

链表（Linked List）

• 特点：动态内存分配，非连续存储，插入/删除效率高。
• 类型：单链表、双链表、循环链表。
• C++ 实现（单链表节点）：

  struct Node {
      int data;
      Node* next;
  };
  

栈（Stack） 

• 特点：后进先出（LIFO），支持 push、pop、peek 操作。
• C++ 实现（使用 STL）：

#include <stack>
std::stack<int> s;
s.push(10);
s.pop();

队列（Queue）

• 特点：先进先出（FIFO），支持 enqueue、dequeue 操作。
• C++ 实现（使用 STL）：

#include <queue>
std::queue<int> q;
q.push(10);
q.pop();

树（Tree）

• 常见类型：二叉树、二叉搜索树（BST）、AVL 树、红黑树。
• 二叉树节点结构：

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
};

图（Graph）

• 表示方法：邻接矩阵、邻接表。
• C++ 实现（邻接表）：

#include <vector>
std::vector<std::vector<int>> graph;

常见算法

排序算法

• 快速排序：分治思想，平均时间复杂度 O(n log n)。

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

•  归并排序：稳定排序，时间复杂度 O(n log n)。

void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

搜索算法

• 二分查找：要求有序数组，时间复杂度 O(log n)。

int binarySearch(int arr[], int l, int r, int x) {
    while (l <= r) {
        int m = l + (r - l) / 2;
        if (arr[m] == x) return m;
        if (arr[m] < x) l = m + 1;
        else r = m - 1;
    }
    return -1;
}

图算法

• 深度优先搜索（DFS）：递归或栈实现。

void DFS(int node, vector<bool>& visited, vector<vector<int>>& graph) {
    visited[node] = true;
    for (int neighbor : graph[node]) {
        if (!visited[neighbor]) {
            DFS(neighbor, visited, graph);
        }
    }
}

•  广度优先搜索（BFS）：队列实现。

void BFS(int start, vector<vector<int>>& graph) {
    queue<int> q;
    vector<bool> visited(graph.size(), false);
    q.push(start);
    visited[start] = true;
    while (!q.empty()) {
        int node = q.front();
        q.pop();
        for (int neighbor : graph[node]) {
            if (!visited[neighbor]) {
                q.push(neighbor);
                visited[neighbor] = true;
            }
        }
    }
}

 动态规划（DP）

•  示例：斐波那契数列（记忆化递归）。

int fib(int n, vector<int>& memo) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n];
    memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
    return memo[n];
}

STL 中的算法与数据结构

• 容器：vector、list、map、set、unordered_map。
• 算法：sort、find、reverse、binary_search。
• 示例：

#include <algorithm>
#include <vector>
std::vector<int> v = {4, 2, 5, 1};
std::sort(v.begin(), v.end()); // 排序

学习资源推荐

1. 书籍：《算法导论》、《C++ Primer》、《数据结构与算法分析》。
2. 在线平台：LeetCode、Codeforces、GeeksforGeeks。
3. 实践建议：从简单数据结构（如数组、链表）开始，逐步实现复杂算法（如动态规划、图算法）。