排序算法_学习笔记（C++）

reasonbao

已于 2024-06-07 22:29:37 修改

阅读量471

点赞数 4

分类专栏： AcWing 文章标签：排序算法学习笔记

于 2020-04-12 01:38:08 首次发布

本文链接：https://blog.csdn.net/qq_44296342/article/details/105463724

版权

AcWing 专栏收录该内容

8 篇文章 3 订阅

订阅专栏

写在前面

快排、归并代码模板来自：https://www.acwing.com/blog/content/277/
作者：yxc

1. 选择排序

时间复杂度：O(n²)
稳定性：稳定
代码实现：

void SelectSort(vector <int> &arr) {
	for (int i = 0; i < arr.size(); i++) {
		for (int j = i+1; j < arr.size(); j++) {
			if (arr[j] < arr[i]) 
				swap(arr[j], arr[i]);	//遇到需要交换的就 次次交换
//			{
//				int tmp = arr[j];
//				arr[j] = arr[i];
//				arr[i]= tmp;
//			}						//初略测试，使用swap函数更快 
		}
	}
}

void SelectSort_2(vector <int> &arr) {
	for (int i = 0; i < arr.size(); i++) {
		int min_sub = i;
		for (int j = i+1; j < arr.size(); j++) {
			if (arr[j] < arr[min_sub]) 
				min_sub = j;			//找本次遍历最小的元素下标 
		}
		swap(arr[min_sub], arr[i]);		//只交换一次，一针见血 
	}
}									//初略测试，大数据量时使用方法 2 速度更快

2. 冒泡排序

算法思想：从头开始依次比较相邻的数，逐步将最大的数置于最后一位，次大的数置于倒数第二位，次次大的数置于倒三位…最小的数置于首位；
代码实现：外循环从尾部开始定位待置的位，内循环从头开始依次冒泡；
代码优化：引入布尔变量，若该次循环一次冒泡（即交换操作）都没有，则表明已经排序完成，直接退出。
时间复杂度：O(n²)
稳定性：稳定
代码实现：

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

void BubbleSort_2(vector <int> &arr) {
	for (int i = arr.size()-1; i >= 0; i--) {
		bool is_swap = false;
		for (int j = 0; j <= i-1; j++) {
			if (arr[j] > arr[j+1]) {
				swap(arr[j], arr[j+1]); 
				is_swap = true;
			}
		}
		if (!is_swap) break;	//一次泡泡都没冒，则已经结束排序 
	}
}

3. 插入排序

算法思想：向一个有序的序列中逐一插入新元素，直至全部元素插入完毕；
代码实现：令首元素（单一）为有序序列，其余元素，逐个找到插入位置进行插入；
时间复杂度：O(n²)
稳定性：稳定
代码实现：

void InsertSort(vector <int> &arr) {
	for (int i = 1; i < arr.size(); i++) {
		int j;
		int tmp = arr[i];		//保存待插元素 
		for (j = i; j > 0; j--) {
			if (arr[j-1] > tmp) arr[j] = arr[j-1];	//后移一位，保留了待插元素副本，故不用担心覆盖 
			else  break;							//找到插入的空位，就停止 
		}
		arr[j] = tmp;
	} 
}

4. 希尔排序

Shell Sort, 不理解，只依稀知道了是设置间隔序列，结合插入排序实现的一种排序算法。

5. 归并排序

yxc大佬：
问题：给定一个序列，用冒泡排序来做的话，需要swap多少次？
ans：即求序列中逆序对的个数。
解决：可用归并排序来求逆序对的个数。用归并排序来求逆序对，这是个超经典问题，很多面试会出现的问题。
哇，我比较笨，思路感觉理解了，但是代码不会实现，那就先模仿yxc大佬的源码！！！
//源码来自：闫学灿大佬

//代码实现 不理解a，那就先模仿。

//源码来自：闫学灿大佬 
void MergeSort(vector<int> &q, int l, int r) {
	if (l >= r) return;
	
	int mid = (l + r) / 2;
	MergeSort(q, l, mid);
	MergeSort(q, mid + 1, r);
	  
	static vector<int> tmp;	//静态的，相当于全局变量 
	tmp.clear();
	
	//归并,两队有序序列合成一队 
	int i = l, j = mid + 1;
	while (i <= mid && j <= r) {
		if (q[i] <= q[j]) {
			tmp.push_back(q[i ++ ]);
		}
		else 
			tmp.push_back(q[j ++ ]);
	} 
	//将未排完的数组全部放进去
	while (i <= mid) tmp.push_back(q[i ++ ]);
	while (j <= r) tmp.push_back(q[j ++ ]);
	
	for (i = l, j = 0; j < tmp.size(); j ++ , i ++ ) q[i] = tmp[j];
}

附一张丑字，跟着代码走一次试试：
哈哈哈哈，开心，今天对代码更理解一点了，能自己敲出来了。——2020/4/15
确认过眼神，没错，就是这个过程！！！而且归并排序也是稳定的，归并的时候条件是 q[左] <= q[右] 即可。
归并排序的应用： 求逆序对
归并过程中，若出现序列1（左）的元素大于序列2（右）的数，则序列1剩下元素的都比序列2中该数大，所以加上此时序列1的元素个数即可。
最后，将每次归并过程中找到的逆序对求和。
求逆序对代码实现：

#include <iostream>
#include <vector>

using namespace std;

int MergeSort_cnt(vector<int> &q, int left, int right) {
	if (left >= right) return 0;	//区间只有一个元素的时候，返回，对应递归结束
	
	int cnt = 0;
	
	int middle = (left + right ) / 2;
	cnt += MergeSort_cnt(q, left, middle);		//否则，排左边 
	cnt += MergeSort_cnt(q, middle+1, right);	//排完左边排右边
	
	//验证，输出排序区间
	cout << "左区间：";	for (int i = left; i <= middle; i ++ ) cout << q[i] << " "; cout << endl; 
	cout << "右区间："; for (int i = middle+1; i <= right; i ++ ) cout << q[i] << " "; cout << endl; 
	cout << "——————\n";
	//开始归并（运行到这的情况1：递归到最后一层，即只有一个元素； 情况2：左边、右边都排好了）
	static vector<int> tmp;
	tmp.clear();		//用static的比较快 
//	vector<int> tmp;
	int i = left, j = middle + 1;
	while (i <= middle && j <= right) {
		if (q[i] <= q[j]) tmp.push_back(q[i ++ ]);
		else {
			tmp.push_back(q[j ++ ]);
			cnt += middle - i + 1;	//找到比其大的，则左边剩下的都比右边大 
		} 
	} 
	while (i <= middle) tmp.push_back(q[i ++ ]);
	while (j <= right) tmp.push_back(q[j ++ ]);
	
	cout << "逆序对：" <<cnt <<endl;  
	cout << "——————\n";
	//此时已经把两个有序数列归并到tmp中，需要放回原数列中
	for (int i = 0, j = left; i < tmp.size(); i ++ ) q[j ++ ] = tmp[i]; 
	return cnt;
}

int main() {
	vector<int> q;
//	q.push_back(8);
//	q.push_back(7);
//	q.push_back(6);
	q.push_back(5);
	q.push_back(4);
	q.push_back(3);
	q.push_back(2);
	q.push_back(1);
//	for (int i = 0; i < 5000; i ++ ) q.push_back(i);
	cout << "Before: ";
	for (int i = 0; i < q.size() ; i++ ) {
		cout << q[i] << " ";
	}
	cout << endl;
	
	cout << MergeSort_cnt(q, 0, q.size() - 1) << "    "; 
	
	cout << "After: ";
	for (int i = 0; i < q.size() ; i++ ) {
		cout << q[i] << " ";
	}
	cout << endl;
	
	return 0;
}

6. 快速排序

哇，闫神的这模板，7行搞定，太强了。
完全不理解…O_O…

void quick_sort(vector<int> &q, int l, int r) {
	if (l >= r) return;
	int i = l - 1, j = r + 1, x = q[l + r >> 1];
	while (i < j) {
		do j -- ; while (q[j] > x);
		do i ++ ; while (q[i] < x);
		if (i < j) swap(q[i], q[j]);
		else quick_sort(q, l, j), quick_sort(q, j+1, r);
	}
}

对该模板的思考：

void quick_sort_bao(vector<int> &q, int l, int r) {
	if (l >= r) return;										//写 l >= r, 比 l == r 适用于越界情况（越界时会左边界大于右边界） 
	int i = l - 1, j = r + 1, x = q[l + r >> 1];
	while (i < j) {
//		do j -- ; while (q[j] > x);
		do j -- ; while (q[j] >= x && j > (l + r >> 1) );	//尝试写成稳定的排序 	test:1  3  2（标记1） 2（标记2） 2（标记3）,嘻嘻，这个是稳定的；
															//然后随便试了一个  3 2 2 2 2，hhhhhh，稳稳地，不稳定，好吧，先学会不稳定的吧hhhhh 
//		do i ++ ; while (q[i] < x);
		do i ++ ; while (q[i] <= x && i < (l + r >> 1) );	//尝试写成稳定的
		if (i < j) swap(q[i], q[j]);
		else quick_sort_bao(q, l, j ), quick_sort_bao(q, j+1, r);	//自动break，相当于while(1), 这个else 改成break	 
	}
}		//注意：  4-17，这个qs(a,b,c),第三个参数问题******* 
		//总结 :由于 该算法出现i、j相遇时，可能情况有 j等于i或是j小于i，而且分界点会有i、j、i==j三种情况 
		//i、i+1   不行 × eg.1 5 2 4 6 
		//i-1、i+1 不行 × eg.1 5 2 4 6
		//j-1、j+1 不行 × eg.1 1 2 0 3 
		//所以
		//只能是 j、j+1，适用于任意情况鸭（三种情况：分界点为i==j、分界点为i、分界点为j） 
		//另外，我认为可以写成稳定排序。 哈，尝试失败 
		//@reasonbao
		//2020/4/16——4/17

快排应用：输出从小到大排序后的第K个数。显然，若每次等排完序，再输出对应位置上的数，很浪费时间，可以有，但没必要。

思路：确定K所在的区间范围，只对该区间进行排序
代码实现：

#include <iostream>

using namespace std;

void QuickChoose(int *A, int l, int r, int k ) {
	if (l >= r) return;
	int i = l - 1, j = r + 1, x = A[(l + r) / 2];	//设定key值 x， 将key放到分界线的位置 
	while(1) {
		do j -- ; while (A[j] > x);
		do i ++ ; while (A[i] < x);
		if (i < j) swap(A[i], A[j]);
		else break;	//排完一趟 
	}
	if (k - 1 <= j) QuickChoose(A, l, j, k);		//思路：每次都判断 K 在左还是右，只对一边排序 
	else QuickChoose(A, j + 1, r, k);
}

int main() {
	int A[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
	int k = 9;
	int len = 10; 
	
	QuickChoose(A, 0, 10 - 1, k);
	
	for (int i = 0; i < len; i++) cout << A[i] << " ";
	cout << endl;
	cout << "第" << k << "个数 = " << A[k - 1];
	return 0; 
}

这次调试又发现一个问题，该快速排序算法存在第一次分割不成左右边序列的情况，但是经过两次while()循环处理，也照样实现了对半分。结果如下所示：

2024年6月7日22:27:27 更新
上图的分析是错的，这个7行快排模板，应该最终达到的效果是区间【L, j】小于【j+1，R】，故递归的时候，只能是

quick_sort_bao(q, l, j ), quick_sort_bao(q, j+1, r)

reasonbao

关注

4
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
排序算法_学习笔记（C++）

选择排序void SelectSort(vector <int> &arr) { for (int i = 0; i < arr.size(); i++) { for (int j = i+1; j < arr.size(); j++) { if (arr[j] < arr[i]) swap(arr[j], arr[i]); //遇...
复制链接

扫一扫