排序算法c++

排序算法

排序是一个非常经典的问题，对一个数组或者一个列表进行重新排序。其中有许多不同的排序算法，每个都有自身的优点和局限性。在对比排序算法通常看两个参数：算法时间复杂度O(N)、稳定性。

排序算法稳定性: 一般来说是能保证在排序前后，数值相等的数字在其序列中的前后位置顺序相同。

稳定性的意义:

1. 如果只是简单的进行数字的排序，那么稳定性将毫无意义。
2. 如果排序的内容仅仅是一个复杂对象的某一个数字属性，那么稳定性依旧将毫无意义。
3. 如果要排序的内容是一个复杂对象的多个数字属性，但是其原本的初始顺序毫无意义，那么稳定性依旧将毫无意义。
4. 除非要排序的内容是一个复杂对象的多个数字属性，且其原本的初始顺序存在意义，那么我们需要在二次排序的基础上保持原有排序的意义，才需要使用到稳定性的算法,例如要排序的内容是一组原本按照价格高低排序的对象，如今需要按照销量高低排序，使用稳定性算法，可以使得想同销量的对象依旧保持着价格高低的排序展现，只有销量不同的才会重新排序。（当然，如果需求不需要保持初始的排序意义，那么使用稳定性算法依旧将毫无意义）。

将 2 8 3 6 2 4 7 1进行排序

1. 冒泡排序

冒泡排序顾名思义，将最大值或者最小值一个个吐出来。每次都是从头开始，可以想象有两个箭头，每次指向相邻两个元素，比较两个元素，若较大元素在前，则交换两个元素，箭头一起向后移动一个单元，直到走到数组的最后一个元素。第1次找出最大值，第2次找出第二大值…，假设有3个数，要进行2次遍历，那么n个数所需外循环次数i为0 ~ n-1。每次遍历后一定有个值找到了自己的位置，所以从该值开始往后都是已经排序好的，再次进行遍历时，到前一位就可以了。第1次从0 ~ n，第2次从0 ~ n-1，第3次从0 ~ n-2，以此类推第i次遍历是从0 ~ n-i-1，所以每次的内循环j的范围是0 ~ n-i-1.

代码

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

void bubbleSort(vector<int>& array) {
	for (int i = 0; i < array.size() - 1; i++) {
		for (int j = 0; j < array.size() - i - 1; j++) {
			if (array[j] > array[j + 1]) {
				swap(array[j], array[j + 1]);
			}
		}
	}
}
void print(vector<int>array) {        //数组打印函数
	for (int i = 0; i < array.size(); i++) {
		cout << array[i];
	}
}

int main() {
	vector<int>array = { 2,8,3,6,2,4,7,1 };
	bubbleSort(array);
	print(array);
	return 0;
}

在代码中，两相邻数交换条件是前一个数大于后一个数，所以两数相同时不会调换位置，排序后的结果是稳定的。如果改变交换条件，大于等于就交换则改变了原来的顺序，变成不稳定。

冒泡排序的改进

上述代码无论是否提前排序完都要将大循坏进行完，例如将13245进行排序，其实只需要一次外循环排序即可，所以可以提前结束程序。具体做法是可以添加flag判断每次大循环后是否发生了交换，如果没有发生交换说明已经排序完成。

void bubbleSort(vector<int>& array) {
	for (int i = 0; i < array.size() - 1; i++) {
		bool swap_flag = false;             //判断是否发生交换
		for (int j = 0; j < array.size() - i - 1; j++) {
			if (array[j] > array[j + 1]) {
				swap(array[j], array[j + 1]);
				swap_flag = true;
			}
			else
			{
				swap_flag = false;
			}
		}
		if (!swap_flag) break;
	}
}

2. 选择排序

选择排序就是每次循环把一组数值最大或最小的找出来，第1次把数组中的最小值找出来放在第1位，第2在剩余的数组找出最小值放在第2位。。。。

代码

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

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

void print(vector<int>array) {        //数组打印函数
	for (int i = 0; i < array.size(); i++) {
		cout << array[i];
	}
}

int main() {
	vector<int>array = { 2,8,3,6,2,4,7,1};
	selectSort(array);
	print(array);
	return 0;
}

另外一种写法，和上述动图写法(内循环记录最小值下标)不一样，每次内循环把最小值放在第一位

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

3. 插入排序

#include"iostream"
#include"vector"
using namespace std;


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

void print(vector<int>array)
{
	for (int i = 0; i < array.size(); i++) {
		cout << array[i] << endl;
	}
}

int main()
{
	vector<int>array = { 2,9,3,7,2,8,5,2 };
	insert_Sort(array);
	print(array);
	return 0;
}

4. 希尔排序

#include"iostream"
#include"vector"
using namespace std;


void shell_Sort(vector<int>&array)
{
	for (int step = array.size()/2; step > 0; step /=2) {
		for (int i = step; i < array.size(); i++) {
			for (int j = i ; j > step-1; j -= step) {
				if (array[j] < array[j-step]) {
					swap(array[j], array[j-step]);
				}
			}
		}
	}
}

void print(vector<int>array)
{
	for (int i = 0; i < array.size(); i++) {
		cout << array[i] << endl;
	}
}

int main()
{
	vector<int>array = { 2,9,3,7,2,8,5,2 };
	shell_Sort(array);
	print(array);
	return 0;
}

4. 快速排序

算法步骤：① 确定分界点：q[l]、q[(l+r)/2]、q[r]
② 调整区间：以阈值分成左右两段，分别是大于小于该值的数
③ 递归处理左右两段