排序算法_学习笔记

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];
}

附一张丑字，手算一遍：
在这里插入图片描述
3. 哈哈哈哈，开心，今天对代码更理解一点了，能自己敲出来了。——2020/4/15

确认过眼神，没错，就是这个过程！！！而且归并排序也是稳定的，归并的时候条件是 q[左] <= q[右] 即可。
在这里插入图片描述
试一下先排右边，再排左边

在这里插入图片描述
4. 求逆序对
归并过程中，若出现序列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

reasonBao

发布了41 篇原创文章 · 获赞 2 · 访问量 1636

私信关注