C++常见算法有哪些

当涉及到常见的算法示例时,以下是一些常见的 C++ 算法及其示例:

1. **排序算法**:
   - 冒泡排序
   - 选择排序
   - 插入排序
   - 归并排序
   - 堆排序
   - 计数排序
   - 桶排序
   - 基数排序

2. **搜索算法**:
   - 线性搜索
   - 二分查找
   - 深度优先搜索(DFS)
   - 广度优先搜索(BFS)

3. **字符串处理算法**:
   - 字符串反转
   - 字符串查找
   - 字符串替换
   - 字符串拼接
   - 字符串分割

4. **图算法**:
   - 最短路径算法(如 Dijkstra 算法、Floyd-Warshall 算法)
   - 最小生成树算法(如 Prim 算法、Kruskal 算法)
   - 拓扑排序算法
   - 深度优先搜索(DFS)和广度优先搜索(BFS)

5. **动态规划算法**:
   - 斐波那契数列
   - 背包问题
   - 最长公共子序列问题
   - 最长递增子序列问题

6. **贪心算法**:
   - 部分背包问题
   - 区间调度问题
   - 霍夫曼编码

1. **冒泡排序**:
   ```cpp
   #include <iostream>
   #include <vector>

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

   int main() {
       std::vector<int> arr = {64, 34, 25, 12, 22, 11, 90};
       bubbleSort(arr);
       for (int num : arr) {
           std::cout << num << " ";
       }
       return 0;
   }
   ```

2. **选择排序**:
   ```cpp
   #include <iostream>
   #include <vector>

   void selectionSort(std::vector<int>& arr) {
       int n = arr.size();
       for (int i = 0; i < n-1; i++) {
           int min_index = i;
           for (int j = i+1; j < n; j++) {
               if (arr[j] < arr[min_index]) {
                   min_index = j;
               }
           }
           std::swap(arr[i], arr[min_index]);
       }
   }

   int main() {
       std::vector<int> arr = {64, 25, 12, 22, 11};
       selectionSort(arr);
       for (int num : arr) {
           std::cout << num << " ";
       }
       return 0;
   }
   ```

3. **插入排序**:
   ```cpp
   #include <iostream>
   #include <vector>

   void insertionSort(std::vector<int>& arr) {
       int n = arr.size();
       for (int i = 1; i < n; i++) {
           int key = arr[i];
           int j = i - 1;
           while (j >= 0 && arr[j] > key) {
               arr[j+1] = arr[j];
               j--;
           }
           arr[j+1] = key;
       }
   }

   int main() {
       std::vector<int> arr = {12, 11, 13, 5, 6, 7};
       insertionSort(arr);
       for (int num : arr) {
           std::cout << num << " ";
       }
       return 0;
   }
   ```

4. **归并排序**:
   ```cpp
   #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 num : arr) {
           std::cout << num << " ";
       }
       return 0;
   }
   ```

5. **堆排序**:
   ```cpp
   #include <iostream>
   #include <vector>
   #include <algorithm>

   void heapify(std::vector<int>& arr, int n, int i) {
       int largest = i;
       int l = 2*i + 1;
       int r = 2*i + 2;
       if (l < n && arr[l] > arr[largest])
           largest = l;
       if (r < n && arr[r] > arr[largest])
           largest = r;
       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 = {12, 11, 13, 5, 6, 7};
       heapSort(arr);
       for (int num : arr) {
           std::cout << num << " ";
       }
       return 0;
   }
   ```

 

1. **线性搜索**:
   ```cpp
   #include <iostream>
   #include <vector>

   int linearSearch(std::vector<int>& arr, int target) {
       for (int i = 0; i < arr.size(); i++) {
           if (arr[i] == target) {
               return i;
           }
       }
       return -1; // 未找到目标值
   }

   int main() {
       std::vector<int> arr = {2, 5, 7, 9, 12, 15};
       int target = 7;
       int index = linearSearch(arr, target);
       if (index != -1) {
           std::cout << "目标值在数组中的索引为:" << index << std::endl;
       } else {
           std::cout << "未找到目标值。" << std::endl;
       }
       return 0;
   }
   ```

2. **二分查找**:
   ```cpp
   #include <iostream>
   #include <vector>

   int binarySearch(std::vector<int>& arr, int target) {
       int left = 0, right = arr.size() - 1;
       while (left <= right) {
           int mid = left + (right - left) / 2;
           if (arr[mid] == target) {
               return mid;
           } else if (arr[mid] < target) {
               left = mid + 1;
           } else {
               right = mid - 1;
           }
       }
       return -1; // 未找到目标值
   }

   int main() {
       std::vector<int> arr = {2, 5, 7, 9, 12, 15};
       int target = 7;
       int index = binarySearch(arr, target);
       if (index != -1) {
           std::cout << "目标值在数组中的索引为:" << index << std::endl;
       } else {
           std::cout << "未找到目标值。" << std::endl;
       }
       return 0;
   }
   ```

1. **最短路径算法 - Dijkstra算法**:
   ```cpp
   #include <iostream>
   #include <vector>
   #include <queue>
   #include <limits>

   #define INF std::numeric_limits<int>::max()

   void dijkstra(std::vector<std::vector<std::pair<int, int>>>& graph, int start) {
       int n = graph.size();
       std::vector<int> dist(n, INF);
       dist[start] = 0;
       std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<std::pair<int, int>>> pq;
       pq.push({0, start});
       while (!pq.empty()) {
           int u = pq.top().second;
           pq.pop();
           for (auto& edge : graph[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});
               }
           }
       }
       for (int i = 0; i < n; i++) {
           std::cout << "从节点 " << start << " 到节点 " << i << " 的最短距禿:" << dist[i] << std::endl;
       }
   }

   int main() {
       int n = 5;
       std::vector<std::vector<std::pair<int, int>>> graph(n);
       graph[0].push_back({1, 4});
       graph[0].push_back({2, 1});
       graph[1].push_back({3, 1});
       graph[2].push_back({1, 2});
       graph[2].push_back({3, 5});
       graph[3].push_back({4, 3});
       dijkstra(graph, 0);
       return 0;
   }
   ```

2. **最小生成树算法 - Prim算法**:
   ```cpp
   #include <iostream>
   #include <vector>
   #include <queue>
   #include <limits>

   #define INF std::numeric_limits<int>::max()

   void prim(std::vector<std::vector<std::pair<int, int>>>& graph) {
       int n = graph.size();
       std::vector<bool> visited(n, false);
       std::vector<int> dist(n, INF);
       dist[0] = 0;
       std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<std::pair<int, int>>> pq;
       pq.push({0, 0});
       while (!pq.empty()) {
           int u = pq.top().second;
           pq.pop();
           visited[u] = true;
           for (auto& edge : graph[u]) {
               int v = edge.first;
               int weight = edge.second;
               if (!visited[v] && dist[v] > weight) {
                   dist[v] = weight;
                   pq.push({dist[v], v});
               }
           }
       }
       int minCost = 0;
       for (int d : dist) {
           minCost += d;
       }
       std::cout << "最小生成树的总权值为:" << minCost << std::endl;
   }

   int main() {
       int n = 5;
       std::vector<std::vector<std::pair<int, int>>> graph(n);
       graph[0].push_back({1, 2});
       graph[0].push_back({3, 6});
       graph[1].push_back({0, 2});
       graph[1].push_back({2, 3});
       graph[1].push_back({3, 8});
       graph[2].push_back({1, 3});
       graph[3].push_back({0, 6});
       graph[3].push_back({1, 8});
       prim(graph);
       return 0;
   }
   ```

1. **部分背包问题**:
   ```cpp
   #include <iostream>
   #include <vector>
   #include <algorithm>

   struct Item {
       int value;
       int weight;
   };

   bool compare(Item a, Item b) {
       double ratio1 = (double)a.value / a.weight;
       double ratio2 = (double)b.value / b.weight;
       return ratio1 > ratio2;
   }

   double fractionalKnapsack(int capacity, std::vector<Item>& items) {
       std::sort(items.begin(), items.end(), compare);
       double maxValue = 0.0;
       for (const Item& item : items) {
           if (capacity == 0) {
               break;
           }
           int weightToAdd = std::min(item.weight, capacity);
           maxValue += weightToAdd * ((double)item.value / item.weight);
           capacity -= weightToAdd;
       }
       return maxValue;
   }

   int main() {
       int capacity = 50;
       std::vector<Item> items = {{60, 10}, {100, 20}, {120, 30}};
       double maxTotalValue = fractionalKnapsack(capacity, items);
       std::cout << "最大总价值为:" << maxTotalValue << std::endl;
       return 0;
   }
   ```

2. **区间调度问题**:
   ```cpp
   #include <iostream>
   #include <vector>
   #include <algorithm>

   struct Interval {
       int start;
       int end;
   };

   bool compareEnd(Interval a, Interval b) {
       return a.end < b.end;
   }

   int intervalScheduling(std::vector<Interval>& intervals) {
       if (intervals.empty()) {
           return 0;
       }
       std::sort(intervals.begin(), intervals.end(), compareEnd);
       int count = 1;
       int end = intervals[0].end;
       for (int i = 1; i < intervals.size(); i++) {
           if (intervals[i].start >= end) {
               count++;
               end = intervals[i].end;
           }
       }
       return count;
   }

   int main() {
       std::vector<Interval> intervals = {{1, 3}, {2, 4}, {3, 6}, {5, 7}, {8, 9}};
       int minRooms = intervalScheduling(intervals);
       std::cout << "需要的最小会议室数量为:" << minRooms << std::endl;
       return 0;
   }
   ```

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/784613.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

前端xss攻击——规避innerHtml过滤标签节点及属性

文章目录 ⭐前言⭐规避innerHtml&#x1f496;在iframe中使用innerHtml的场景&#x1f496;标签转义&#x1f496;url 进行encode&#x1f496;手动过滤内容转义 ⭐inscode代码块演示⭐结束 ⭐前言 大家好&#xff0c;我是yma16&#xff0c;本文分享xss攻击——规避innerHtml过…

Java学习笔记NO.29

Java容器 在Java编程中&#xff0c;容器是一种用于存储和管理数据的数据结构。Java提供了丰富的容器类库&#xff0c;包括List、Set、Map等&#xff0c;以及它们的实现类ArrayList、HashSet、HashMap等。 1. 列表&#xff08;List&#xff09; 列表是一种有序的集合&#xf…

list(链表)容器(一)

一、list基本概念 链表&#xff08;list&#xff09;是一种物理存储单元上非连续的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成&#xff1a;链表由一系列结点组成 结点的组成&#xff1a;一个是存储数据元素的数据域&#xff0…

webpack.prod.js(webpack生产环境配置文件)

生产环境&#xff1a;只打包不运行本地服务器 对于在config目录下的webpack.prod.js 1.在根目录下运行 npx webpack --config ./config/webpack.prod.js 2.在package.json文件中配置 "build":"npx webpack --config ./config/webpack.prod.js" const …

正弦实时数据库(SinRTDB)的使用(11)-限制磁盘空间

前文已经将正弦实时数据库的使用进行了介绍&#xff0c;需要了解的可以先看下面的博客&#xff1a; 正弦实时数据库(SinRTDB)的安装 正弦实时数据库(SinRTDB)的使用(1)-使用数据发生器写入数据 正弦实时数据库(SinRTDB)的使用(2)-接入OPC DA的数据 正弦实时数据库(SinRTDB)…

通过pymysql读取数据库中表格并保存到excel(实用篇)

本篇文章是通过pymysql将本地数据库中的指定表格保存到excel的操作。 这里我们假设本地已经安装了对应的数据库管理工具&#xff0c;里面有一个指定的表格&#xff0c;现在通过python程序&#xff0c;通过调用pymysql进行读取并保存到excel中。 关于数据库管理工具是Navicat P…

【题解】—— LeetCode一周小结13

【题解】—— 每日一道题目栏 上接&#xff1a;【题解】—— LeetCode一周小结12 25.零钱兑换 II 题目链接&#xff1a;518. 零钱兑换 II 给你一个整数数组 coins 表示不同面额的硬币&#xff0c;另给一个整数 amount 表示总金额。 请你计算并返回可以凑成总金额的硬币组合…

NVIDIA Jetson Xavier NX入门-镜像为jetpack5(3)——pytorch和torchvision安装

NVIDIA Jetson Xavier NX入门-镜像为jetpack5&#xff08;3&#xff09;——pytorch和torchvision安装 镜像为jetpack5系列&#xff1a; NVIDIA Jetson Xavier NX入门-镜像为jetpack5&#xff08;1&#xff09;——镜像烧写 NVIDIA Jetson Xavier NX入门-镜像为jetpack5&#…

PI案例分享--2000A核心电源网络的设计、仿真与验证

目录 摘要 0 引言 1 为什么需要 2000A 的数字电子产品? 2 2000A 的供电电源设计 2.1 "MPM3698 2*MPM3699"的 MPS扩展电源架构 2.2 使用恒定导通时间(COT)模式输出核心电压的原因 2.3 模块化 VRM 的优势 2.4 用步进负载验证2000A的设计难点 2.4.1 电源网络 …

机器人---人形机器人之技术方向

1 背景介绍 在前面的文章《行业杂谈---人形机器人的未来》中&#xff0c;笔者初步介绍了人形机器人的未来发展趋势。同智能汽车一样&#xff0c;它也会是未来机器人领域的一个重要分支。目前地球上最高智慧的结晶体就是人类&#xff0c;那么人形机器人的未来会有非常大的发展空…

【深度学习】球衣号码识别 re-id追踪

1. CLIP-ReIdent: Contrastive Training for Player Re-Identification 论文解析–2023的论文&#xff0c;貌似顶会 论文方法是类不可知的&#xff0c;微调CLIP vitl/14模型&#xff0c;在MMSports 2022球员重新识别挑战中实现98.44%的mAP。此外&#xff0c;CLIP Vision Trans…

在 C#和ASP.NET Core中创建 gRPC 客户端和服务器

关于gRPC和Google protobuf gRPC 是一种可以跨语言运行的现代高性能远程过程调用 (RPC) 框架。gRPC 实际上已经成为 RPC 框架的行业标准&#xff0c;Google 内外的组织都在使用它来从微服务到计算的“最后一英里”&#xff08;移动、网络和物联网&#xff09;的强大用例。 gRP…

SQLite3进行数据库各项常用操作

目录 前言1、SQLite介绍2、通过SQLite创建一个数据库文件3、往数据库文件中插入数据4、数据库文件信息查询5、修改数据库中的内容6、删除数据库中的内容 前言 本文是通过轻量化数据库管理工具SQLite进行的基础操作和一些功能实现。 1、SQLite介绍 SQLite是一个广泛使用的嵌入…

[C++面向对象]很难蒙混过关的CArray3d三维数组模板类

07:很难蒙混过关的CArray3d三维数组模板类 描述 实现一个三维数组模版CArray3D&#xff0c;可以用来生成元素为任意类型变量的三维数组&#xff0c;输出指定结果 #include <iostream> #include <iomanip> #include <cstring> using namespace std; templ…

微信小程序如何进行npm导入组件

文章目录 目录 文章目录 前言 一、安装node 二、微信小程序通过npm安装组件&#xff08;以Vant-weapp为例&#xff09; 一、Vant-weapp下载 二 、修改 app.json 三 、修改 project.config.json 四 、 构建 npm 包 前言 微信小程序使用npm导入有很多的教程&#xff0c;我…

vue基础教程(5)——十分钟吃透vue路由router

同学们可以私信我加入学习群&#xff01; 正文开始 前言一、路由概念二、路由使用三、创建路由对应的组件四、给整个项目一个入口总结 前言 前面的文章运行成功后&#xff0c;页面显示如下&#xff1a; 在这个页面中&#xff0c;点击Home和About都会切换右面的页面内容&#…

一百以内累加(C语言)

一、运行结果&#xff1b; 二、源代码&#xff1b; # define _CRT_SECURE_NO_WARNINGS #include <stdio.h>int main() {//初始化变量值&#xff1b;int a 2;int result 1;//循环运算&#xff1b;while (a < 100){//加&#xff1b;result a result;//改变变量值&a…

Spring(详细介绍)

目录 一、简介 1、什么是Spring&#xff1f; 2、Spring框架的核心特性 3、优点 二、IOC容器 介绍 1、获取资源的传统方式 2、控制反转方式获取资源 3、DI 4、IOC容器在Spring中的实现 入门案例 1、创建Maven Module 2、引入依赖 3、创建HelloWorld类 4、在Spring的配…

【动手学深度学习】深入浅出深度学习之利用神经网络识别螺旋状数据集

目录 &#x1f31e;一、实验目的 &#x1f31e;二、实验准备 &#x1f31e;三、实验内容 &#x1f33c;1. 生成螺旋状数据集 &#x1f33c;2. 打印数据集 &#x1f33c;3. 编程实现 &#x1f33b;仿射层-Affine类 &#x1f33b;传播层-Sigmoid类 &#x1f33b;损失函数…

Unity urp渲染管线下,动态修改材质球surfaceType

在项目中遇到了需要代码动态修改材质球的surfaceType&#xff0c;使其动态切换是否透明的需求。 urp渲染管线下&#xff0c;动态修改材质球的surfaceType&#xff0c;查了大部分帖子&#xff0c;都有一些瑕疵&#xff0c;可能会造成透明后阴影投射有问题。 其次在webgl平台上…