C++十大经典算法案例

1. 排序算法：

• 冒泡排序：

  void bubbleSort(int arr[], int n) {
      for (int i = 0; i < n - 1; ++i)
          for (int j = 0; j < n - i - 1; ++j)
              if (arr[j] > arr[j + 1]) swap(arr[j], arr[j + 1]);
  }
  

• 快速排序：

  int partition(int arr[], int low, int high) {
      int pivot = arr[high];
      int i = (low - 1);
      for (int j = low; j <= high - 1; j++) {
          if (arr[j] < pivot) {
              i++;
              swap(&arr[i], &arr[j]);
          }
      }
      swap(&arr[i + 1], &arr[high]);
      return (i + 1);
  }
  
  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);
      }
  }
  

2. 搜索算法：

• 二分查找：

  int binarySearch(int arr[], int l, int r, int x) {
      if (r >= l) {
          int mid = l + (r - l) / 2;
          if (arr[mid] == x) return mid;
          if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
          return binarySearch(arr, mid + 1, r, x);
      }
      return -1;
  }
  

3. 图算法：

• Dijkstra最短路径算法（仅核心逻辑）：

  priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
  vector<int> dist(n, INT_MAX); // 初始化距离数组
  dist[src] = 0;
  pq.push({0, src}); // 将源点加入优先队列
  
  while (!pq.empty()) {
      int u = pq.top().second;
      pq.pop();
      
      for (auto& edge : adj[u]) {
          int v = edge.first;
          int weight = edge.second;
          if (dist[v] > dist[u] + weight) {
              dist[v] = dist[u] + weight;
              pq.push({dist[v], v});
          }
      }
  }
  

4. 动态规划：

• 最长公共子序列（LCS）：

  string lcs(string X, string Y, int m, int n) {
      int L[m + 1][n + 1];
      for (int i = 0; i <= m; i++) {
          for (int j = 0; j <= n; j++) {
              if (i == 0 || j == 0)
                  L[i][j] = 0;
              else if (X[i - 1] == Y[j - 1])
                  L[i][j] = L[i - 1][j - 1] + 1;
              else
                  L[i][j] = max(L[i - 1][j], L[i][j - 1]);
          }
      }
      // 回溯构造LCS字符串，此处省略...
      return lcsString;
  }
  

5. 贪心算法：

• 活动选择问题（假设每个活动有开始和结束时间）：

  vector<int> findMaxActivities(vector<pair<int, int>>& activities) {
      sort(activities.begin(), activities.end());
      vector<int> result;
      int end = activities[0].first;
      for (int i = 1; i < activities.size(); ++i) {
          if (activities[i].first >= end) {
              result.push_back(i);
              end = activities[i].second;
          }
      }
      return result;
  }
  

当然，接下来再介绍几个其他的经典算法：

6. 树与图算法：

• 二叉树的前序遍历（递归实现）：

  struct TreeNode {
      int val;
      TreeNode* left;
      TreeNode* right;
      TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  };
  
  void preorderTraversal(TreeNode* root) {
      if (root == NULL) return;
      cout << root->val << " ";
      preorderTraversal(root->left);
      preorderTraversal(root->right);
  }
  

7. 字符串处理算法：

• KMP算法匹配子串：

  void computeLPSArray(string pat, int M, vector<int>& lps) {
      int len = 0;
      lps[0] = 0;
      int i = 1;
      while (i < M) {
          if (pat[i] == pat[len]) {
              len++;
              lps[i] = len;
              i++;
          } else {
              if (len != 0) {
                  len = lps[len-1];
              } else {
                  lps[i] = 0;
                  i++;
              }
          }
      }
  }
  
  int KMPSearch(string pat, string txt) {
      int M = pat.length();
      int N = txt.length();
      vector<int> lps(M);
      computeLPSArray(pat, M, lps);
  
      int i = 0, j = 0;
      while (i < N) {
          if (pat[j] == txt[i]) {
              i++;
              j++;
          }
          if (j == M) {
              return i - j; // 返回匹配到的位置
          } else if (i < N && pat[j] != txt[i]) {
              if (j != 0)
                  j = lps[j-1];
              else
                  i = i + 1;
          }
      }
      return -1; // 如果未找到返回-1
  }
  

8. 位运算算法：

• 判断一个整数是否为2的幂：

  bool isPowerOfTwo(int n) {
      return n > 0 && (n & (n - 1)) == 0;
  }
  

9. 数学相关算法：

• 计算斐波那契数列：

  long long fibonacci(int n) {
      if (n <= 1) return n;
      long long fib[n+2]; 
      fib[0] = 0;
      fib[1] = 1;
      for (int i=2; i<=n; i++)
          fib[i] = fib[i-1] + fib[i-2];
      return fib[n];
  }
  

10. 数据结构算法：

- 链表反转：
  ```cpp
  struct Node {
      int data;
      Node* next;
      Node(int x) : data(x), next(NULL) {}
  };

  Node* reverseList(Node* head) {
      Node* prev = NULL;
      Node* current = head;
      Node* next;
      while (current != NULL) {
          next = current->next;
          current->next = prev;
          prev = current;
          current = next;
      }
      head = prev;
      return head;
  }
  ```

以上就是一些经典的C++算法案例，涵盖多个不同的领域和应用场景。在实际编程中，根据具体需求灵活运用这些算法能有效提高程序性能和解决问题的效率。

python推荐学习汇总连接：
50个开发必备的Python经典脚本(1-10)

50个开发必备的Python经典脚本(11-20)

50个开发必备的Python经典脚本(21-30)

50个开发必备的Python经典脚本(31-40)

50个开发必备的Python经典脚本(41-50)
————————————————

​最后我们放松一下眼睛