你知道的C++经典算法有哪些

于 2024-08-18 20:34:54 发布
阅读量543 收藏 6
点赞数 21
分类专栏： 计算机篇 文章标签： 算法 c++ 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangjinhu/article/details/141304900
版权

C++作为一门功能强大且广泛应用的编程语言，其在算法领域的应用十分广泛。掌握一些经典的算法不仅能够提高程序的效率，还能增强解决复杂问题的能力。本文将介绍一些在C++中广泛应用的经典算法，包括排序算法、搜索算法、图算法、动态规划等。

1. 排序算法

1.1 快速排序（Quick Sort）

快速排序是一种基于分治思想的排序算法，其基本思想是通过一个基准元素将数组分为两部分，使得一部分元素小于基准元素，另一部分元素大于基准元素，然后递归地对两部分分别进行快速排序。其平均时间复杂度为O(n log n)。

#include <iostream>
#include <vector>

int partition(std::vector<int>& arr, int low, int high) {
    int pivot = arr[high];
    int i = low - 1;

    for (int j = low; j < high; ++j) {
        if (arr[j] < pivot) {
            ++i;
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[i + 1], arr[high]);
    return i + 1;
}

void quickSort(std::vector<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);
    }
}

int main() {
    std::vector<int> arr = {10, 7, 8, 9, 1, 5};
    quickSort(arr, 0, arr.size() - 1);
    for (int i : arr) {
        std::cout << i << " ";
    }
    return 0;
}

1.2 归并排序（Merge Sort）

归并排序同样是一种分治算法，其基本思想是将数组递归地分成两半，分别进行排序，然后再将两个有序的数组合并成一个有序数组。归并排序的时间复杂度为O(n log n)，但其空间复杂度较高。

#include <iostream>
#include <vector>

void merge(std::vector<int>& arr, int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;

    std::vector<int> L(n1), R(n2);

    for (int i = 0; i < n1; ++i)
        L[i] = arr[l + i];
    for (int j = 0; j < n2; ++j)
        R[j] = arr[m + 1 + j];

    int i = 0, j = 0, k = l;

    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            ++i;
        } else {
            arr[k] = R[j];
            ++j;
        }
        ++k;
    }

    while (i < n1) {
        arr[k] = L[i];
        ++i;
        ++k;
    }

    while (j < n2) {
        arr[k] = R[j];
        ++j;
        ++k;
    }
}

void mergeSort(std::vector<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);
    }
}

int main() {
    std::vector<int> arr = {12, 11, 13, 5, 6, 7};
    mergeSort(arr, 0, arr.size() - 1);
    for (int i : arr) {
        std::cout << i << " ";
    }
    return 0;
}

1.3 堆排序（Heap Sort）

堆排序是一种基于二叉堆数据结构的排序算法。它将待排序的序列构造成一个大顶堆（或小顶堆），然后依次取出堆顶元素并调整堆以保证其有序。堆排序的时间复杂度为O(n log n)，且不需要额外的内存空间。

#include <iostream>
#include <vector>

void heapify(std::vector<int>& arr, int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;

    if (left < n && arr[left] > arr[largest])
        largest = left;

    if (right < n && arr[right] > arr[largest])
        largest = right;

    if (largest != i) {
        std::swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(std::vector<int>& arr) {
    int n = arr.size();

    for (int i = n / 2 - 1; i >= 0; --i)
        heapify(arr, n, i);

    for (int i = n - 1; i > 0; --i) {
        std::swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

int main() {
    std::vector<int> arr = {4, 10, 3, 5, 1};
    heapSort(arr);
    for (int i : arr) {
        std::cout << i << " ";
    }
    return 0;
}

2. 搜索算法

2.1 二分查找（Binary Search）

二分查找是一种高效的搜索算法，适用于在有序数组中查找特定元素。其基本思想是将数组从中间一分为二，与目标值比较后选择在左半部分或右半部分继续查找，直到找到目标值或范围缩小为空。二分查找的时间复杂度为O(log n)。

#include <iostream>
#include <vector>

int binarySearch(const std::vector<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;
}

int main() {
    std::vector<int> arr = {2, 3, 4, 10, 40};
    int x = 10;
    int result = binarySearch(arr, 0, arr.size() - 1, x);
    if (result == -1)
        std::cout << "Element not present in array";
    else
        std::cout << "Element found at index " << result;
    return 0;
}

2.2 深度优先搜索（Depth-First Search, DFS）

深度优先搜索是一种图遍历算法，其基本思想是沿着一个分支不断向下搜索，直到无法继续为止，然后回溯并从其他分支继续搜索。DFS常用于解决连通性问题、生成迷宫、寻找路径等。时间复杂度为O(V + E)，其中V是顶点数，E是边数。

#include <iostream>
#include <vector>

void DFSUtil(int v, std::vector<bool>& visited, const std::vector<std::vector<int>>& adj) {
    visited[v] = true;
    std::cout << v << " ";

    for (int i : adj[v])
        if (!visited[i])
            DFSUtil(i, visited, adj);
}

void DFS(int v, const std::vector<std::vector<int>>& adj) {
    std::vector<bool> visited(adj.size(), false);
    DFSUtil(v, visited, adj);
}

int main() {
    std::vector<std::vector<int>> adj = {
        {1, 2},
        {0, 3, 4},
        {0, 5},
        {1},
        {1},
        {2}
    };

    DFS(0, adj);
    return 0;
}

2.3 广度优先搜索（Breadth-First Search, BFS）

广度优先搜索是另一种图遍历算法，其基本思想是从一个起始顶点出发，依次访问其所有邻接顶点，然后再从这些顶点出发继续访问其未被访问的邻接顶点，直到所有顶点都被访问。BFS常用于求解最短路径问题。时间复杂度为O(V + E)。

#include <iostream>
#include <vector>
#include <queue>

void BFS(int v, const std::vector<std::vector<int>>& adj) {
    std::vector<bool> visited(adj.size(), false);
    std::queue<int> q;

    visited[v] = true;
    q.push(v);

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        std::cout << u << " ";

        for (int i : adj[u]) {
            if (!visited[i]) {
                visited[i] = true;
                q.push(i);
            }
        }
    }
}

int main() {
    std::vector<std::vector<int>> adj = {
        {1, 2},
        {0, 3, 4},
        {0, 5},
        {1},
        {1},
        {2}
    };

    BFS(0, adj);
    return 0;
}

3. 动态规划（Dynamic Programming）

3.1 最长公共子序列（Longest Common Subsequence, LCS）

最长公共子序列问题是经典的动态规划问题，其目标是在两个序列中找到最长的公共子序列。通过构建一个二维DP表格，逐步填充每个子问题的最优解，从而得到整个问题的解。时间复杂度为O(n * m)，其中n和m分别为两个序列的长度。

#include <iostream>
#include <vector>
#include <string>

int LCS(const std::string& X, const std::string& Y) {
    int n = X.size();
    int m = Y.size();
    std::vector<std::vector<int>> dp(n + 1, std::vector<int>(m + 1, 0));

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            if (X[i - 1] == Y[j - 1])
                dp[i][j] = dp[i - 1][j - 1] + 1;
            else
                dp[i][j] = std::max(dp[i - 1][j], dp[i][j - 1]);
        }
    }

    return dp[n][m];
}

int main() {
    std::string X = "AGGTAB";
    std::string Y = "GXTXAYB";
    std::cout << "Length of LCS is " << LCS(X, Y);
    return 0;
}

3.2 背包问题（Knapsack Problem）

背包问题是另一个经典的动态规划问题，其目标是在给定物品的重量和价值的情况下，选择物品装入背包使得背包中的物品总价值最大化，而不超过背包的容量。使用动态规划可以有效解决这一问题，时间复杂度为O(n * W)，其中n为物品数，W为背包容量。

#include <iostream>
#include <vector>

int knapSack(int W, const std::vector<int>& wt, const std::vector<int>& val, int n) {
    std::vector<std::vector<int>> dp(n + 1, std::vector<int>(W + 1, 0));

    for (int i = 1; i <= n; ++i) {
        for (int w = 1; w <= W; ++w) {
            if (wt[i - 1] <= w)
                dp[i][w] = std::max(val[i - 1] + dp[i - 1][w - wt[i - 1]], dp[i - 1][w]);
            else
                dp[i][w] = dp[i - 1][w];
        }
    }

    return dp[n][W];
}

int main() {
    std::vector<int> val = {60, 100, 120};
    std::vector<int> wt = {10, 20, 30};
    int W = 50;
    int n = val.size();
    std::cout << "Maximum value in Knapsack = " << knapSack(W, wt, val, n);
    return 0;
}

4. 图算法

4.1 Dijkstra算法

Dijkstra算法用于求解单源最短路径问题，特别是在图中不存在负权边的情况下。其基本思想是从起点开始，逐步找到到其他顶点的最短路径，直到所有顶点都被访问。时间复杂度为O(V^2)或O((V + E) log V)（使用优先队列时）。

#include <iostream>
#include <vector>
#include <queue>

const int INF = 1e9;

void dijkstra(int src, const std::vector<std::vector<std::pair<int, int>>>& adj) {
    int n = adj.size();
    std::vector<int> dist(n, INF);
    dist[src] = 0;

    std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<std::pair<int, int>>> pq;
    pq.push({0, src});

    while (!pq.empty()) {
        int u = pq.top().second;
        pq.pop();

        for (const auto& p : adj[u]) {
            int v = p.first;
            int weight = p.second;

            if (dist[v] > dist[u] + weight) {
                dist[v] = dist[u] + weight;
                pq.push({dist[v], v});
            }
        }
    }

    for (int i = 0; i < n; ++i) {
        std::cout << "Distance from " << src << " to " << i << " is " << dist[i] << "\n";
    }
}

int main() {
    std::vector<std::vector<std::pair<int, int>>> adj = {
        {{1, 4}, {2, 1}},
        {{3, 1}},
        {{1, 2}, {3, 5}},
        {}
    };

    dijkstra(0, adj);
    return 0;
}

4.2 Floyd-Warshall算法

Floyd-Warshall算法用于求解图中任意两点间的最短路径问题。其基本思想是通过动态规划逐步更新路径长度，直到所有顶点对之间的最短路径长度都被计算出来。时间复杂度为O(V^3)。

#include <iostream>
#include <vector>

const int INF = 1e9;

void floydWarshall(std::vector<std::vector<int>>& dist) {
    int n = dist.size();
    for (int k = 0; k < n; ++k) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (dist[i][k] < INF && dist[k][j] < INF)
                    dist[i][j] = std::min(dist[i][j], dist[i][k] + dist[k][j]);
            }
        }
    }
}

int main() {
    std::vector<std::vector<int>> dist = {
        {0, 3, INF, INF},
        {2, 0, INF, INF},
        {INF, 7, 0, 1},
        {6, INF, INF, 0}
    };

    floydWarshall(dist);

    for (const auto& row : dist) {
        for (int d : row) {
            if (d == INF)
                std::cout << "INF ";
            else
                std::cout << d << " ";
        }
        std::cout << "\n";
    }

    return 0;
}

老梁爱分享
关注
  • 21
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【2024最新版】PCL点云处理算法汇总（C++长期更新版）
点云侠的博客
02-27 57万+
PCL学习目录。博客长期更新，最近一次更新时间为：2024年8月16日。
C++排序算法：归并排序详解
小天狼星_布莱克 的博客
07-17 3万+
C++排序算法：归并排序详解
C/C++经典算法——约瑟夫问题
热门推荐
青春无问西东 岁月自成芳华
07-26 11万+
C/C++经典算法——约瑟夫问题 什么是约瑟夫问题 一行代码解决约瑟夫问题！！！
c++十大经典排序算法
客舟中
12-28 6553
代码 1 冒泡排序 冒泡排序是一种简单直观的入门排序算法。它的原理就是从第一个元素开始，与后面的元素逐个比较，如果顺序不对就交换，直到没有可比较的元素为止。 1 // 冒泡排序 2 void BublingSort(int *arr, int len) 3 { 4 if(len == 0) 5 { 6 return; 7 } 8 std::cout<<"冒泡排序"<<std::endl; 9 for(i
c++常见算法
qq_51691366的博客
04-16 4885
find 查找自定义数据类型 需要重载==private:int num;public:Person(){}//find 查找自定义数据类型 需要重载==if(ret!cout
5 大最常用 C++ 经典算法
青春不老，奋斗不止！
07-20 7002
置顶/星标公众号????，硬核文章第一时间送达！一、冒泡排序冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素...
C++常见算法大全（自用）
ylh的博客
08-27 6292
集合算法主要是集合上的一些运算，例如集合加法：并集，集合的减法：差集，还有交集。stable_partition: 范围排序，保存原容器顺序。partial_sort_copy:范围排序外加复制操作。next_permutation:下一个排序序列的组合。prev_permutation:上一个排序序列的组合。stable_sort: 排序，保存原容器数据顺序。remove_copy_if:条件删除拷贝到新容器。replace_copy_if:条件替换，结果另存。......
C++经典算法
weixin_43908980的博客
05-05 1万+
以下博客供大家借鉴：（注意，前方含精量高能） 目录 一.数论 二.容斥专题 三.图论&搜索 四.DP&递推 五.总结 六.单调队列&栈 七.树状数组 八.线段树 九.STL 十.矩阵加速专题 十一.高级搜索 十二.最近公共祖先LCA 十三.2019暑假篇 十四.树链剖分 十五.概率 十六.网络流 十七.主席树 十八.平衡树...
C++ 补充之常用遍历算法
百锦再的博客
02-27 2万+
通过transform算法，可以方便地对容器中的每个元素进行转换操作，并将结果存储在另一个容器中，减少了显式循环的编写。通过for_each算法，可以方便地对容器中的每个元素进行操作，而不需要显式地编写循环。transform算法用于对序列中的每个元素应用指定的操作，并将结果存储在另一个序列中。find算法用于在容器中查找指定值第一次出现的位置，返回指向第一个等于该值的元素的迭代器，若未找到，则返回迭代器指向容器的末尾。通过使用这些算法，可以方便地对容器中的元素进行各种不同的操作和处理。
C++算法之贪心算法
一个程序猿~
05-23 5080
贪心算法是一种求解最优解问题的算法，它的核心思想是每一步都采取当前状态下最优的选择，从而最终得到全局最优解。它是C++重要的一种算法。本文会介绍贪心算法。
C++常用经典算法源码
12-01
"C++常用经典算法源码"集合了多个核心算法领域的实现，对于学习和提升C++编程技能，以及深入理解算法原理极具价值。 首先，我们来看"第1章 高精度计算"。高精度计算涉及到大整数运算，通常在标准库类型无法满足精度...
C++递归算法实例代码
08-28
1. 递归算法的特点：递归算法有三个特点：基本部分、递归部分和分治法思想。基本部分是直接满足条件的输出，递归部分是通过改变基数（即n）来逐步使得n满足基本部分的条件，从而输出。分治法思想是将整体分割成部分...
经典手眼标定算法C++代码
02-19
经典手眼标定算法C++代码，程序是基于OpenCV 2.0以上版本，下载程序后需要配置OpenCV。工程主要包括三个文件，handeye.h为各种手眼标定的实现，quaternion.h为四元数运算文件，handeye_test.cpp为主程序，测试各手眼...
c++经典算法好和2 好好好好好好2好好
01-19
在IT领域，C++是一种强大的编程语言，以其高效性能、面向对象特性和广泛的应用而闻名。而算法则是计算机科学的基石，是解决复杂问题的有效工具...在不断迭代的IT行业中，熟练掌握算法和精通C++将使你具备更强的竞争力。
C++经典数值算法源码.rar_c++ 数值_c++数值算法_c++经典算法%2_c数值算法_数值算法
09-15
本资源“C++经典数值算法源码.rar”提供了20个用Visual C++编写的经典数值算法，涵盖了多个重要的计算领域。 1. **插值算法**：插值是数值分析的基础，用于找到一个函数或数据点集的近似表达，使得在已知点上与原始...
备战秋招60天算法挑战，Day17
溜达虎的博客
08-13 396
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
算法的学习笔记—删除链表中重复的结点（牛客JZ76）
最新发布
业精于勤，荒于嬉
08-14 1201
本文介绍了一种删除排序链表中重复节点的高效算法。通过递归的方式，算法能够有效地删除所有重复节点，并保留链表中仅出现一次的节点。此方法的实现简单且易于理解，同时在时间和空间复杂度方面表现优异，适用于处理大规模数据链表中的重复节点问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 787
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
【LeetCode每日一题】——623.在二叉树中增加一行
IronmanJay的博客
08-14 1133
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
C++中有哪些经典算法
06-06
C++中有很多经典算法，以下是一些常见的： 1. 快速排序（Quick Sort） 2. 归并排序（Merge Sort） 3. 堆排序（Heap Sort） 4. 二分查找（Binary Search） 5. 最短路径算法（Dijkstra、Bellman-Ford、Floyd） 6. 最小生成树算法（Prim、Kruskal） 7. 动态规划算法（Dynamic Programming） 8. 贪心算法（Greedy Algorithm） 9. 搜索算法（DFS、BFS） 10. 字符串匹配算法（KMP、Boyer-Moore、Rabin-Karp） 当然，除了以上列举的算法，还有很多其他经典的算法，这些算法都是在算法领域内被广泛使用并且具有重要意义的算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

老梁爱分享

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值