c++算法笔记(更新中)

算法

排序算法

排序算法基本分为八种

• 冒泡排序
• 插入排序
• 堆排序
• 选择排序
• 快速排序
• 归并排序
• 基数排序
• 希尔排序

当然，并不要求完全掌握全部的排序方法。虽然如此，理解其中的实现原理是很有必要的。这为我们遇到相似问题时提供思路

遇到排序问题时可以使用头文件algorthm中的sort()和stable_sort()函数来实现排序

sort()的实现用的是快速排序，并不稳定。需要稳定排序时可以用stable_sort()来实现，实现是归并排序。

两个排序的复杂度都是O(nlogn),但普遍地快速排序比归并排序快，所以在不需要稳定排序的情况下使用sort()来排序

sort()用法

两个参数sort(起始地址，末尾地址+1)；

默认是升序排序。

代码示例：

#include<iostream>
#include<algorithm>
using namespace std;
int main(){
	int a[10]={2,5,1,7,3,9,0,4,8,6};
	sort(a,a+10);
	for(int i = 0; i < 10; i++){
		cout<<a[i]<<' ';
	}
} 
/*
输出:
0 1 2 3 4 5 6 7 8 9 
*/

三个参数sort(起始地址，末尾地址+1,排序函数地址)；

示例代码：

#include<iostream>
#include<algorithm>
bool cmp(int v1,int v2){
	return v1>v2;
}
using namespace std;
int main(){
	int a[10]={2,5,1,7,3,9,0,4,8,6};
	sort(a,a+10,cmp);
	for(int i = 0; i < 10; i++){
		cout<<a[i]<<' ';
	}
} 
/*
输出:
9 8 7 6 5 4 3 2 1 0
*/

并查集

并查集虽然不是主流算法，但仍是很有必要学会的，它的作用并不小，在处理集合问题时显得无可替代

作用：

就是分集合，查看两个对象是否属于同一个集合。

原理：

1. 用一个数组 f[i] 来实现，并初始化数组 f[i] = i
2. 构建一定关系
3. 需要一个find()函数查找

示例代码：

#include<iostream>
using namespace std;
//并查集数组 
int f[10];
//查找函数 
int find(int value){
	if(value!=f[value])return f[value]=find(f[value]);
	return value;
}
int main(){
	//初始化f[i]数组 
	for(int i = 0; i < 10; i++){
		f[i]=i;
	} 
	//下面构建集合{0},{1,2,3,4},{5},{6,7,8,9}
	f[find(1)]=find(2);
	f[find(1)]=find(3);
	f[find(1)]=find(4);
	f[find(6)]=find(7);
	f[find(6)]=find(8);
	f[find(6)]=find(9);
	//打印理解
	for(int i = 0; i < 10; i++){
		cout<<i<<" 属于集合 "<<find(i)<<endl; 
	} 
} 
/*
输出:
0 属于集合 0
1 属于集合 4
2 属于集合 4
3 属于集合 4
4 属于集合 4
5 属于集合 5
6 属于集合 9
7 属于集合 9
8 属于集合 9
9 属于集合 9
*/

搜索

二分搜索

二分搜索非常适合线性搜索，即问题具有一定的递增性或递减性，例如在0-1000000000中找一个数字，如果按照普通顺序的逐个检查将用会产生巨大的时间开销。二分搜索的时间复杂度为O(logn),大大地缩减了时间开销

原理：

1. 取三个值，left = 最小范围 - 1 ,right = 最大范围 + 1,middle = (left + right)/2;
2. 如果middle取值比理想中的要大，令 right = middle + 1,反则 left = middle - 1;
3. 重复步骤2，直到middle == 理想值；

（注：以上是搜索整数的用法）

例题：

从0x80000000+1 到 0x7fffffff-1 中搜索1个数

示例代码：

#include<iostream>
using namespace std;
int main(){
	cout<<"请输入一个 "<<(int)0x80000000+1<<" 到 "<<0x7fffffff-1<<" 的数字"<<endl;
	int value;
	cin>>value;
	int l= (int)0x80000000;
	int r= (int)0x7fffffff;
	int ans=0;
	while(1){
		ans++;
		int m=(l+r)/2;
		if(m==value){
			cout<<m<<endl<<"搜索次数: "<<ans;
			break;
		}
		if(m>value){
			r=m+1;
		}else{
			l=m-1;
		}
	}
}

/*
输出:
请输入一个 -2147483648 到 2147483646 的数字
5
5
搜索次数: 32
*/

三分搜索

三分搜索适用于类抛物线求最值

原理：

1. 取四个值，left = 最小范围,right = 最大范围,middle1 = left + (left - right)/3，middle2 = right - (left + right)/3
2. 前提需要知道类抛物线开口向上还是向下，如果开口向上，即求最小值，如果middle1>middle2,令left=middle1,反则right=middle2
3. 重复步骤2，直到right - left == 一定精度

深度优先搜索

常叫dfs(Depth first search)，搜索一种问题的所有可能

原理：

1. 实现递归函数dfs(),按实际情况取参数

例题：

在地图
.s.#.
..#..
.#...
.#...
...e.
中s是入口,e是出口,#是障碍。每次只能走一步(上下左右)
求最短的步数

示例代码：

#include<iostream>
using namespace std;
//最小步数 
int minStep=0x7fffffff;
//地图 
char map[5][5]={'.','s','.','#','.','.','.','#','.','.','.','#','.','.','.','.','#','.','.','.','.','.','.','e','.'};
//标记数组，用来回溯 
int sign[5][5]={0};
//dfs函数 
void dfs(int step,int x,int y){
	if(map[y][x]=='e'){
		minStep=min(minStep,step);
	}
	//分别是上下左右 
	int m[4][2]{0,1,0,-1,-1,0,1,0};
	for(int i = 0; i < 4; i++){
		int x1=x+m[i][0];
		int y1=y+m[i][1];
		if(x1>=0&&x1<5&&y1>=0&&y1<5&&map[x1][y1]!='#'&&sign[y1][x1]==0){
			sign[y1][x1]=1;
			dfs(step+1,x+m[i][0],y+m[i][1]);
			//回溯 
			sign[y1][x1]=0;
		}
	}
}
int main(){
	int x,y;
	//找出起点 
	for(int i = 0; i < 5; i++){
		for(int j = 0; j < 5; j++){
			if(map[i][j]=='s'){
				x=j;
				y=i;
			}
		}
	}
	//dfs 
	dfs(0,x,y); 
	cout<<minStep<<endl;
}
/*
输出:
8

*/

宽度优先搜索

常叫bfs(Width first search),一般用于最短路径问题

原理

1. 用数据结构queue实现
2. 一步一步搜索，搜到的就是最短路径

例题

与上同题

示例代码:

#include<iostream>
#include<queue>
using namespace std;
class node{
	public:
	int x,y,step;
};
int main(){
	//地图 
	char map[5][5]={'.','s','.','#','.','.','.','#','.','.','.','#','.','.','.','.','#','.','.','.','.','.','.','e','.'};
	//标记数组 
	int sign[5][5]={0};
	queue<node> q;
	node p;
	//找出起点 
	for(int i = 0; i < 5; i++){
		for(int j = 0; j < 5; j++){
			if(map[i][j]=='s'){
				p.x=j;
				p.y=i;
				p.step=0;
			}
		}
	}
	q.push(p);
	sign[p.y][p.x]=1; 
	//bfs
	while(!q.empty()){
		//分别是上下左右 
		int m[4][2]{0,1,0,-1,-1,0,1,0};
		node d=q.front();
		q.pop();
		if(map[d.y][d.x]=='e'){
			cout<<d.step<<endl;
			break;
		}
		for(int i = 0; i < 4; i++){
			int x1=d.x+m[i][0];
			int y1=d.y+m[i][1];
			if(x1>=0&&x1<5&&y1>=0&&y1<5&&map[x1][y1]!='#'&&sign[y1][x1]==0){
				sign[y1][x1]=1;
				node e;
				e.x=x1;
				e.y=y1;
				e.step=d.step+1;
				q.push(e);
			}
		}
	}
	
}
/*
输出:
8

*/

动态规划

动态规划(Dynamic Programming),简称dp,通过维护记忆化dp数组减少重复步骤的计算，大大减低时间复杂度

典型例题:

求最长递增子串长度，如f[8]={1，4，2，3，5，8，6，7}。答案是6，{1，2，3，5，6，7}

理解:

1. 用dp[n]储存0~n之间的最大连续子串长度
2. 如dp[0]=1,因为f[1]>f[0],所以有dp[1]=max(dp[1],dp[0]+1)
3. 一直执行步骤2，直到遍历数组

示例代码：

#include<iostream>
#include<string> 
using namespace std;
int main(){
	int f[8]={1,4,2,3,5,8,6,7};
	int dp[8];
	string s[8];
	//初始化dp[],s[]
	for(int i=0;i<8;i++){
		dp[i]=1;
		s[i]+=to_string(f[i]);
	}
    //dp
	for(int i=0;i<8;i++){
		for(int j=0;j<i;j++){
			if(f[i]>f[j]){
				if(dp[i]<dp[j]+1){
					dp[i]=dp[j]+1;
					s[i]=s[j]+to_string(f[i]);
				}
			}
		}
	}
    int ma=0;
    for(int i=1;i<8;i++){
        if(dp[ma]<dp[i]){
            ma=i;
        }
    }
    cout<<dp[ma]<<endl;
    cout<<"{";
    for(int i=0;i<s[ma].size();i++){
        if(i!=0){
            cout<<',';
        }
        cout<<s[ma][i];
    }
    cout<<'}';
}

/*
输出:
6
{1,2,3,5,6,7}
*/

图论

最小生成树

最小花费

滑动窗口