算法起飞--持续更新中ing

已于 2025-05-11 17:12:21 修改
阅读量579 收藏 19
点赞数 22
分类专栏： 算法 文章标签： c++ 开发语言 java 算法
于 2025-05-10 15:42:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74907886/article/details/147854039
版权

C++STL的学习

STL的学习对之后使用各种STL特性来完成算法有极大帮忙

int a{2};//初始化

vector<int>a;

#注意空格也是一个字符

#include <iostream>

#include <string>

 

void replaceSubstring(std::string& str, const std::string& s, const std::string& t) {

    size_t startPos = 0; // 初始化起始搜索位置为0

         //find(从str中要找的元素,从字符串哪个位置开始)   //当find没有找到目标字符返回npos

    while ((startPos = str.find(s, startPos)) != std::string::npos) {

        // 调用 string 类的成员函数 replace 进行替换

        // 将从 startPos 开始的子串 s 替换为 t

        //string& replace(pos, n, t) 替换从pos位置开始的需要替换n个字符为t

        str.replace(startPos, s.length(), t);

        startPos += t.length();  // 移动起始搜索位置到替换后的位置

    }

}

 

int main() {

    std::string str ="ababcd"; // 原始字符串

    std::string s{"ab"};  // 要被替换的子串

    std::string t = "123";  // 用来替换的新串

 

    // 调用替换函数，替换原始字符串中的子串

    replaceSubstring(str, s, t);

 

    // 输出替换后的字符串

    std::cout << "替换后的字符串为：" << str << std::endl;

 

    return 0;

}

#include<iostream>

#include<algorithm>//包含sort的头文件

using namespace std;

 

struct student {

    std::string name;

    int score;

};

 

bool com(student& a, student& b)//定义函数从大到小排序

{

    return a.score > b.score;

}

 

int main()

{

    student stu[5] = { {"Alice", 85},{"Bob", 92},{"Charlie", 78},{"David", 92},{"Eve", 85} };

    std::sort(stu, stu + 5, com);

    //sort(开始位置，结束位置，排序方法)

    std::cout << "输出"<<std::endl;

    for (int i = 0; i < 5; i++)

    {

        std::cout << stu[i].name<<" " << stu[i].score << std::endl;

    }

}

 

#include<iostream>

#include<vector>

#include<set>

using namespace std;

int setfind(vector<int>& v, int k)

{

    set<int> s;

//set<int,greater<int>>s; 会使s中元素从大到小排序

    for (int e : v)//遍历容器 v 中的每个元素，将每个元素依次赋值给 e

        s.insert(e);//set容器中s使用insert后会自动去重复元素并排序

    auto it = s.begin();  //it：标识符 

    //迭代器：遍历用的

    for (int i = 1; i < k; i++)

        it++;

    return *it;

 

}

 

int main()

{

    vector<int> v= { 1, 1, 2, 2, 3, 3, 4, 4, 6 };

    int k;

    cin >> k;

    int t=setfind(v, k);

    cout << t;

}

练习

//统计各元素出现次数

#include<iostream>

#include<map>

#include<vector>

using namespace std;



vector<int> mapfind(vector<int>& v, int k)

{

vector<int> ans;

map<int,int,greater<int>> mp;

for (auto e : v)

mp[e]++;

auto it = mp.begin();

for (int i = 0; i < k && it != mp.end(); i++)

{

ans.push_back(it->first);//ans[1]:2, ans[2]:1, ans[3]:2

//it->first 表示迭代器 it 指向的键值对中的键

ans.push_back(it->second);

//it->second键值对中的值

it++;

}

return ans;



}

int main()

{

vector<int> v = { 1,1,2,3,3 };

vector<int>ans;

ans=mapfind(v, 3);



for (auto it = ans.begin(); it!=ans.end(); it++)



{

cout << *it<<" ";



}



}

算法

 迭代法       

思想：旧值推新值，新值赋旧值

子集（LeetCode78）
给定一个整数数组 nums，长度范围是1～10，其中所有元素互不相同。求该数组所有可能的子集（幂集），结果中不能包含重复的子集，可以按任意顺序返回幂集。
例如， nums=[1，2，3]，结果为[[]，[1]，[2]，[1，2]，[3]，[1，3]，[2，3]，[1，2，3]]。
//幂集
#include<iostream>
#include<vector>

using namespace std;

vector<vector<int>>append(vector<vector<int>>M1, int x)
{
    vector<vector<int>>A = M1;
    for (int j = 0; j < A.size(); j++)
    {
        A[j].push_back(x);
    }
    return A;
}

vector<vector<int>> mj(int n)
{
    vector<vector<int>>M;//存放所有幂集
    vector<vector<int>>M1 = { {},{1} };//设M1为1的幂集
    if (n == 1)return M1;
    for (int i = 2; i <= n; i++)
    {
        vector<vector<int>>A = append(M1, i);
        M = M1;
        for (int j = 0; j < A.size(); j++)
        {
            M.push_back(A[j]);
        }
        M1= M;
    }
    return M;
}



int main()
{
    vector<vector<int>>nums;
    int n = 3;
    nums=mj(n);
    for (auto it : nums)
    {
        for (auto num : it)
        {
            cout << num << " ";
        }
        cout << endl;
    }
    
}

分治算法

思想：先分两个，然后通过两个递归合起来

对于给定的含有n个整数的无序序列，求这个序列中最大和次大的两个不同的元素。


#include<iostream>
#include<vector>
using namespace std;


//           [5,3,4,8,1,7]                 // 初始数组
//         /          \
//       [5,3,4]         [8,1,7]             // 第一次分割
//     /   \           /    \
//   [5,3]  [4]       [8,1]  [7]           // 第二次分割
//    / \   (max=min)  / \ 
//  [5] [3]          [8] [1]               // 第三次分割
//（max）(min)       ...
void findmax(vector<int>& num, int start,int end,int &max,int &min)
{
	if (start == end)
	{
		max = num[start];
		min = num[start];
		return;
	}
	if (start + 1 == end)
	{
		if (num[start] > num[end]) {
			max = num[start];
			min= num[end];
		}
		else {
			max = num[end];
			min= num[start];
		}
		return;
	}

	int mid = (start + end) / 2;
	int lmax, lmin;
	int rmax,rmin;
	findmax(num, start, mid, lmax, lmin);                                                   
	findmax(num, mid+1, end, rmax, rmin);

	max = std::max(lmax, rmax);
	min = std::max(std::min(lmax, rmax), std::max(lmin, rmin));

}


int main()
{
	vector<int>num = { 5,3,4,8,1,7 };
	int n = num.size();
	int max, min;
	findmax(num, 0, n - 1, max, min);
	cout << "最大" << max;
	cout << "次大" << min;
}

回溯法

给定n个不同的正整数集合a=(ao，a1，..，an-1）和一个正
整数t，要求找出a的子集s，使该子集中所有元素的和为t。
例如，当n=4时，a=（3，1，5，2），t8，则满足要求的子
集s为（3，5）和（1，5，2）
#include<iostream>
#include<vector>
using namespace std;
//cs:左边 已相加的和   rs:右边  剩余的未相加的
void play(vector<int>&x,vector<int>a) {
	for (int i= 0; i < x.size(); i++) {
		if(x[i] == 1)
		{
			cout << a[i]<<" ";
		}
	}
	cout << endl;
}
void DFS(int cs, int rs, vector<int>&x, int i,vector<int>a) {
	if (i >=4)
	{
		if (cs == 8)
			play(x,a);
	}
	else {
		rs -= a[i];
		if(cs+a[i]<=8)
		{
			x[i] = 1;
			DFS(cs+a[i], rs, x, i + 1,a);
		}
		if (cs + rs >= 8) {
			x[i] = 0;
			DFS(cs, rs, x, i + 1, a);
		}
		rs += a[i];
	}
}
int main() {
	vector<int>a = { 3,1,5,2 };
	vector<int>x = { 0,0,0,0 };
	DFS(0, 11, x, 0, a);
}

贪心法


(LeetCode45)
给定一个含n(1<n<1000)个非负整数
数组nums(0<numslil<1000)，数组中的每个元素表示在该位置可
以跳跃的最大长度，假设总是可以从初始位置0到达最后一个位置n-1，
设计一个算法求最少的跳跃次数。
例如nums={2，3，1，1，4}，n=5，从位置0可以跳1步到达位置1,
再从位置1跳3步到达位置4，所以结果为2。

#include<iostream>
#include<vector>
using namespace std;

int jump(vector<int>&num)
{
	int n = num.size();
	int maxp = 0;//最远距离
	int step = 0;//跳了多少步
	int end = 0;//最远
	for (int i = 0; i < n - 1; i++) {//num[i]+i
		maxp = max(maxp, num[i] + i);//取范围内跳的最远的
		if (end == i) {//当跳到边界处
			end = maxp;
			step++;
		}
	}
	return step;
}

int main()
{
	vector<int>num = { 2,3,1,1,4 };
	cout<<"跳" << jump(num)<<"次";
}

【聚类算法】K-means算法
大雨淅淅的博客
09-16 4933
K-means算法是一种常用的聚类分析方法，其目的是将n个数据点划分为k个簇，使得每个数据点属于离它最近的均值（即簇中心）对应的簇，以此来最小化簇内的平方误差之和。
算法系列：最短路径问题详解——Dijkstra算法、Floyd-Warshall算法、Bellman-Ford算法（SPFA算法）
闵行小鱼塘
09-15 1396
本篇归纳最短路径问题，从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径，主要有三种算法：Dijkstra算法、Floyd-Warshall算法、Bellman-Ford算法（SPFA算法）
西工大2023新版C语言NOJ（持续更新中）
m0_71919496的博客
10-03 9535
西工大2023新版C语言NOJ答案记录，第一篇博客，欢迎大佬们批评指正，期待更好的算法和更优化的代码。本篇内容仅供交流学习，读者因其他用途造成的一切后果与本人无关。
西北工业大学noj2023年c程序设计100题，更新中
热门推荐
m0_54007497的博客
10-02 9万+
noj2023新版解题思路
2023西工大NOJ (C语言版) 完结！！！
annesede的博客
10-11 7万+
代码均可AC，不含解析。
Java SE进阶笔记（更新ing）
Spring伦儿的博客
09-03 738
Java SE进阶笔记一级目录二级目录三级目录 一级目录 二级目录 三级目录
算法Day30 | 332.重新安排行程，51. N皇后，37. 解数独，总结ing
雨后的放线君
06-08 660
zsbd
记忆力-英二
丘色果
04-11 4844
第 1 章 熟词僻义 —— 熟词僻义 ============================================================================================================ box [bɑːks] n.盒;箱;匣; v.(拳击运动)击打(某人);把(某物)装箱(或盒、匣) He boxes the waiter in the box. 他在包厢里出拳打了那个服务员。 se.
2017-12 CDQZ集训(已完结)
weixin_30779691的博客
12-16 369
从联赛活了下来（虽然分数倒一……），接下来要去CDQZ集训啦…… DAY -2 2017-12-16 被老师安排负责一部分同学的住宿以及安排…… 抓紧时间继续学习，LCT真好玩啊真好玩…… 晚上放假了…… DAY -1 2017-12-17 放假进行中……下午转场到了石家庄。 与srs，wzz，wxh几个dalao住在一个宾馆，晚上出去吃饭…… DAY 0 2017-12-18 ...
程序员逻辑英语——回归理性——中英文对切基本公式（1-1）
w524254582的博客
09-29 2007
转自https://blog.csdn.net/bhhgg8552/article/details/80113427   公式的运行和词汇语法重建 一个公式破解天下句子 我们将完成一个数据模型去重构句子体系，这是一个接近理科的思想，就是集合论的思想，从集合的角度我们发现两种语言之间本质上是排序不同，单词是对称的么，我们先假设你都认识单词了，语法也都懂了，先不管这些问题，先完成这个逻辑的重建...
钟平程序员逻辑英语——回归理性——中英文对切基本公式（1-1）
多读书读好书的博客
04-28 1万+
公式的运行和词汇语法重建一个公式破解天下句子我们将完成一个数据模型去重构句子体系，这是一个接近理科的思想，就是集合论的思想，从集合的角度我们发现两种语言之间本质上是排序不同，单词是对称的么，我们先假设你都认识单词了，语法也都懂了，先不管这些问题，先完成这个逻辑的重建，我们会发现中文和英文的单词是一样的，中文有书英文就有Book，他是一个对称体系，差别在于，外语的排列方式和中文是不一样的，我们中国各...
最短路径算法---有向图
weixin_41563161的博客
03-01 7252
最短路径算法---有向图、 算法实现思路 拓扑排序，其实就是寻找一个入度为0的顶点，该顶点是拓扑排序中的第一个顶点序列，将之标记删除，然后将与该顶点相邻接的顶点的入度减1，再继续寻找入度为0的顶点，直至所有的顶点都已经标记删除或者图中有环。 从上可以看出，关键是寻找入度为0的顶点。 一种方式是遍历整个图中的顶点，...
机器学习-常见聚类算法K-means，模糊c-均值，谱聚类 DBSCAN算法等
qq_41275074的博客
08-02 3221
常见聚类算法
分类算法matlab实例,数据挖掘之分类算法---knn算法(有matlab例子)
weixin_28419039的博客
03-17 4483
knn算法(k-Nearest Neighbor algorithm).是一种经典的分类算法.注意,不是聚类算法.所以这种分类算法必然包括了训练过程.然而和一般性的分类算法不同,knn算法是一种懒惰算法.它并非像其他的分类算法先通过训练建立分类模型.,而是一种被动的分类过程.它是边测试边训练建立分类模型.算法的一般描述过程如下:1.首先计算每个测试样本点到其他每个点的距离.这个距离可以是欧氏距离,...
C++ string小记
xmu_cjs的博客
05-16 108
【代码】C++ string小计。
学习笔记（C++篇）—— Day 6
最新发布
2406_83392683的博客
05-17 704
int main()//申请空间//申请空间+构造函数//只释放空间free(p1);//析构函数 + 释放空间delete p2;delete p3;return 0;注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。由于C++的这些用法，用C++写链表会使得过程更加简便。
深入理解C++智能指针：shared_ptr、unique_ptr与weak_ptr
Chinese_chen_的博客
05-13 906
C++11引入的智能指针（std::shared_ptr、std::unique_ptr和std::weak_ptr）通过RAII机制简化了内存管理，减少了内存泄漏和悬垂指针的风险。std::shared_ptr允许多个指针共享对象所有权，基于引用计数自动释放资源，但需注意循环引用问题。std::unique_ptr独占所有权，不可复制但可通过移动语义转移所有权，适合单一作用域内的资源管理。std::weak_ptr作为shared_ptr的观察者，不增加引用计数，用于解决循环引用问题。最佳实践包括优先使用
深入浅出：C++数据处理类与计算机网络的巧妙类比
weixin_56334307的博客
05-13 831
在计算机编程中，我们常常会遇到一些看似简单的代码结构，却能巧妙地映射到复杂的计算机网络概念中。本文将通过一个简单的C++数据处理类，探讨其与计算机网络中硬件设备和协议的类比关系，帮助读者更好地理解抽象的网络概念。
C++八股——平衡树总结
m0_46329175的博客
05-17 735
简要总结了数据结构中常见的平衡树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值