经典排序算法入门总结（一）

刷题的时候陆陆续续把排序算法学得七七八八，但是回忆起来感觉非常的零散，所以想对经典排序算法做一个整理，配上动画图解加最便于理解的代码，写给小白和我自己，大佬勿喷哈哈哈

十大经典排序算法总结如下图：

排序算法分类

排序算法可以分为内部排序和外部排序。

内部排序是数据记录在内存中进行排序。

而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

规则不同：插入、交换、选择、归并……

时间复杂度不同：简单排序O(N^2)，先进排序O(NlogN)

关于时间复杂度：

1. 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。
2. 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；
3. O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序
4. 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。

关于稳定性：

1. 稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。
2. 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

1、冒泡排序(Bubble Sort)

1-基本思想

从第一个元素向上比较，若大于下一个则交换，每一轮交换之后，序列中最大的数一定会被换到未排序的最后一个。

2-复杂度

最坏情况O(N^2)

最好情况O(N)

3-稳定性

稳定

4-代码模板

#include<iostream>
using namespace std;

//辅助函数，打印数组
void print_arr(int arr[], int n, int swapped){
	for(int i = 0; i < n; i ++){
		printf("%d ", arr[i]);
	}
	printf("%s", swapped ? "swapped" : "not swapped");
	putchar('\n');
} 

void bubble_sort(int arr[], int n){
	//外层循环：逐层扫描
	//i>1的原因，只有一个元素的数组自然有序 
	for(int i = n; i > 1; i --){
		int swapped = 0;//是否发生交换的标志 
		for(int j = 1; j < i; j ++){
			if(arr[j - 1] > arr[j]){
				swap(arr[j - 1], arr[j]);
				swapped = 1;
			}
		} 
		print_arr(arr, n, swapped);
		if(!swapped){ //若无交换发生，结束 
			break;
		}
	} 
	 
} 

int main(){
	int arr[] = {5, 2, 7, 6, 1, 4, 3};
	print_arr(arr, 7, 0);
	
	bubble_sort(arr, 7);
	
	return 0;
} 

//运行结果
5 2 7 6 1 4 3 not swapped
2 5 6 1 4 3 7 swapped
2 5 1 4 3 6 7 swapped
2 1 4 3 5 6 7 swapped
1 2 3 4 5 6 7 swapped
1 2 3 4 5 6 7 not swapped

2、选择排序(Selection Sort)

1-基本思想

每一趟在后面n - i + 1个中选出关键值最小的对象，作为有序序列的第i个记录（每次选择最小的（最大），放在已排序集合的后面）

2-复杂度

与元素组成无关：O(N^2)，（每一轮都要找最小的）

移动次数 最好0，最坏3(n - 1)

比较次数n(n - 1) / 2

时间复杂度O(n^2)

3-稳定性

稳定

比较时使用小于，稳定

使用小于等于，不稳定

4-代码模板

#include<iostream>
using namespace std;

//辅助函数，打印数组
void print_arr(int arr[], int n){
	for(int i = 0; i < n; i ++){
		printf("%d ", arr[i]);
	}
	putchar('\n');
} 


void selection_sort(int arr[], int n){
	int min;
	for(int i = 0; i < n; i ++){
		min = i;
		for(int j = i + 1; j < n; j ++){
			if(arr[j] < arr[min]){
				min = j;
			}
		}
		swap(arr[min], arr[i]);
		print_arr(arr, n); 
	}
} 

int main(){
	int arr[] = {15, 5, 2, 7, 12, 6, 1, 4, 3, 9, 8, 10};
	print_arr(arr, 12);
	
	selection_sort(arr, 12);
	
	return 0;
} 

//运行结果：
15 5 2 7 12 6 1 4 3 9 8 10
1 5 2 7 12 6 15 4 3 9 8 10
1 2 5 7 12 6 15 4 3 9 8 10
1 2 3 7 12 6 15 4 5 9 8 10
1 2 3 4 12 6 15 7 5 9 8 10
1 2 3 4 5 6 15 7 12 9 8 10
1 2 3 4 5 6 15 7 12 9 8 10
1 2 3 4 5 6 7 15 12 9 8 10
1 2 3 4 5 6 7 8 12 9 15 10
1 2 3 4 5 6 7 8 9 12 15 10
1 2 3 4 5 6 7 8 9 10 15 12
1 2 3 4 5 6 7 8 9 10 12 15
1 2 3 4 5 6 7 8 9 10 12 15

3、插入排序(Insertion Sort)

1-基本思想：

每步将一个待排序的对象，按其关键值大小，插入到前面已经排好序的一组对象的适当位置上，指导对象全部插入为止。

不同实现方式：

直接插入排序（基于顺序查找）

折半插入排序（基于折半查找）

希尔排序（基于逐趟缩小增量）

2-复杂度

最好（比较N次），最坏（比较n(n - 1) / 2次）

3-稳定性

直接插入排序：

4-代码模板

#include<stdio.h>

void print_arr(int arr[], int n){
	for(int i = 0; i < n; i ++){
		printf("%d ", arr[i]);
	}
	printf("\n");
}

void insertion_sort(int arr[], int n){
	print_arr(arr, n);
	for(int i = 1; i < n; i ++){
		int key = arr[i];       //把要排序的值存起来，以便直接覆盖，不用swap交换，省时间 
		int j = i - 1;
		while(j >= 0 && arr[j] > key){
			arr[j + 1] = arr[j];
			j --; 
		}
		arr[j + 1] = key;
		print_arr(arr, n);
	}
}

int main(){
	int arr[] = {10, 8, 11, 7, 4, 12, 9, 6, 5, 3};
	int n = 10; 
	insertion_sort(arr, n);
	
	return 0;
}

运行结果：
10 8 11 7 4 12 9 6 5 3
8 10 11 7 4 12 9 6 5 3
8 10 11 7 4 12 9 6 5 3
7 8 10 11 4 12 9 6 5 3
4 7 8 10 11 12 9 6 5 3
4 7 8 10 11 12 9 6 5 3
4 7 8 9 10 11 12 6 5 3
4 6 7 8 9 10 11 12 5 3
4 5 6 7 8 9 10 11 12 3
3 4 5 6 7 8 9 10 11 12

4、希尔排序(Shell Sort)

希尔排序可以理解为增量递减的插入排序

1-基本思想

希尔排序需要使用一个增量序列，例如1、3、5

因为每趟排序间隔主键缩小，希尔排序也成为“缩小增量排序”

2-复杂度分析

希尔排序的复杂度依赖于增量序列，如何最优尚未有定论，但最后一个gap必须为1

可能有同学会有疑问了：反正最后都是gap为1的插入排序，为啥不一开始就直接进行插入排序呢？

答：这实际上是一种宏观调控，其实在进行前面的增量gap的插入排序时，序列在一步步变得有序，在最后虽然也要进行gap=1的插入排序，但是交换的次数变少了，从而实现复杂度的优化。

除了一些简单的序列，其他序列的复杂度证明是一个长期为解决的问题

所有序列中最坏的情况O(N^2)

Hibbard增量序列：最坏O(N^ 3/2)，（模拟平均结果【无人能证明】：O(N^ 5/4)）

Sedgewick增量序列：最坏O(N^ 4/3)，（模拟平均结果【猜测】：O(N^ 7/6)）(目前最好)

3-稳定性

不稳定

4-代码模板

#include<iostream>
#include<stdio.h>
using namespace std;

//辅助函数，打印数组
void print_arr(int arr[], int n){
	for(int i = 0; i < n; i ++){
		printf("%d ", arr[i]);
	}
	putchar('\n');
} 

void shell_sort(int arr[], int n){
	int i, j, inc, key;      //inc增量 
	//初始增量：n/2，每趟之后除以二
	for(inc = n / 2; inc > 0; inc /= 2){
		//每一趟采用插入排序,对每一组都进行了插入排序 
		for(i = inc; i < n; i ++){
			key = arr[i];    //要插入的元素 
			for(j = i; j >= inc && key < arr[j - inc]; j -= inc){
				arr[j] = arr[j - inc];
			}
			arr[j] = key;
		} 
		print_arr(arr, n);
	} 
}

int main(){
	int arr[] = {15, 5, 2, 7, 12, 6, 1, 4, 3, 9, 8, 10};
	print_arr(arr, 12);
	
	shell_sort(arr, 12);
	print_arr(arr, 12);
	
	return 0;
}

//运行结果
15 5 2 7 12 6 1 4 3 9 8 10
1 4 2 7 8 6 15 5 3 9 12 10
1 4 2 7 5 3 9 8 6 15 12 10
1 2 3 4 5 6 7 8 9 10 12 15
1 2 3 4 5 6 7 8 9 10 12 15

先鸽了， 未完待续……