刷题的时候陆陆续续把排序算法学得七七八八,但是回忆起来感觉非常的零散,所以想对经典排序算法做一个整理,配上动画图解加最便于理解的代码,写给小白和我自己,大佬勿喷哈哈哈
十大经典排序算法总结如下图:
排序算法分类
排序算法可以分为内部排序和外部排序。
内部排序是数据记录在内存中进行排序。
而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。
常见的内部排序算法有:插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。
规则不同:插入、交换、选择、归并……
时间复杂度不同:简单排序O(N^2),先进排序O(NlogN)
关于时间复杂度:
- 平方阶 (O(n2)) 排序 各类简单排序:直接插入、直接选择和冒泡排序。
- 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序;
- O(n1+§)) 排序,§ 是介于 0 和 1 之间的常数。 希尔排序
- 线性阶 (O(n)) 排序 基数排序,此外还有桶、箱排序。
关于稳定性:
- 稳定的排序算法:冒泡排序、插入排序、归并排序和基数排序。
- 不是稳定的排序算法:选择排序、快速排序、希尔排序、堆排序。
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
先鸽了, 未完待续……