一文总结十大经典排序算法（思维导图 + 动图演示 + 代码实现 C/C++/Python + 致命吐槽）

声明

1）该文章整理自网上的大牛和专家无私奉献的资料，具体引用的资料请看参考文献。
2）本文仅供学术交流，非商用。如果某部分不小心侵犯了大家的利益，还望海涵，并联系博主删除。
3）博主才疏学浅，文中如有不当之处，请各位指出，共同进步，谢谢。
4）此属于第一版本，若有错误，还需继续修正与增删。还望大家多多指点。大家都共享一点点，一起为祖国科研的推进添砖加瓦。

0、写在前面

最近终于是学到了排序算法，

排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。

为什么排序算法在很多领域被相当地重视？

主要是一个优秀的算法可以节省大量的资源，尤其是在大量数据的处理方面。

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

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

经典排序算法主要有一下几个（思维导图）：

点击查看大图！

主要的性质肯定少不了：

• 数据对象

数据对象：
数组或者链表，或者both。

• 稳定性

稳定性：
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且 r[i] 在 r[j] 之前，而在排序后的序列中，r[i] 仍在 r[j] 之前，则称这种排序算法是 稳定 的；否则称为 不稳定 的。

• 时间复杂度

时间复杂度：
时间复杂性，又称时间复杂度，是一个定性描述该算法的运行时间的函数。

• 空间复杂度

空间复杂度：
空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。

点击查看大图！

1、冒泡排序

描述：

重复地走访要排序的元素列，依次比较两个相邻的元素，如果顺序错误，就把他们交换。

动图演示：

• 什么时候最快？
  当输入的数据已经是正序时（？？？那还用排序？都已经是正序了，还要你何用）。
• 什么时候最慢？
  当输入的数据是反序时（死心眼嘛？循环反序再输出数据不就行了，还用你是闲的吗）。
  

代码：

#python
def bubbleSort(arr):
    for i in range(1, len(arr)):
        for j in range(0, len(arr)-i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

//C
void swap(int *a,int *b){
   
    int temp = *a;
    *a = *b;
    *b = temp;
}
void bubble_sort(int arr[], int len){
   
    int i, j, temp;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - 1 - i; j++)
            if (arr[j] > arr[j + 1]) {
   
            	swap(&arr[j], &arr[j + 1]);
            }
}

//C++
template<typename T>
void bubble_sort(T arr[], int len) {
   
    int i, j;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - 1 - i; j++)
            if (arr[j] > arr[j + 1])
                swap(arr[j], arr[j + 1]);
}

写一个 Swap 交换和 flag 提前跳出，加上第一层倒序循环，是可以的。

---

参考MOOC浙大数据结构

// C
void Swap(ElementType *a, ElementType *b){
   
	ElementType t = *a; *a = *b; *b = t;
}
void BubbleSort(ElementType A[], int N){
   
	int P, i;
	int flag;
	for (P = N - 1; P >= 0; P--){
   
		flag = 0;
		for (i = 0; i < P; i++){
   
			if (A[i] > A[i + 1]){
   
				Swap(&A[i], &A[i + 1]);
				flag = 1;
			}
		}
		if (flag = 0) break;
	}
}

2、选择排序

描述：

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。

动图演示：

（其实就是打牌，抓牌，看牌，马牌）

代码：

#python
def selectionSort(arr):
    for i in range(len(arr) - 1):
        # 记录最小数的索引
        minIndex = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[minIndex]:
                minIndex = j
        # i 不是最小数时，将 i 和最小数进行交换
        if i != minIndex:
            arr[i], arr[minIndex] = arr[minIndex], arr[i]
    return arr

//C
void swap(int *a,int *b){
   
    int temp = *a;
    *a = *b;
    *b = temp;
}
void selection_sort(int arr[], int len){
   
    int i,j;
    for (i = 0 ; i < len - 1 ; i++){
   
        int min = i;
        //遍历未排序的元素
        for (j = i + 1; j < len; j++){
   
            if (arr[j] < arr[min])    	//找到目前最小值
                min = j;    			//记录最小值
        	swap(&arr[min], &arr[i]);   //做交換
        }
    }
}

//C++
template<typename T> 
void selection_sort(std::vector<T>& arr) {
   
    for (int i = 0; i < arr.size() - 1; i++) {
   
        int min = i;
        for (int j = i + 1; j < arr.size(); j++){
   
            if (arr[j] < arr[min])
                min = j;
        	std::swap(arr[i], arr[min]);
        }
    }
}

---

参考MOOC浙大数据结构

// C
void Swap(ElementType *a, ElementType *b){
   
	ElementType t = *a; *a = *b; *b = t;
}
void SimpleSelectionSort(ElementType A[], int N){
   
	int i, j, min;
	for (i = 0; i < N-1; i++){
   
		min = i;
		for (j = i + 1; j < N; j++){
   
			if (A[i] < A[min])
				min = j;
			Swap(&A[i], &A[min]);
		}
	}
}

3、插入排序

描述：

通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

动图演示：

（慢，真的慢，不是假的）

代码：

#python
def insertionSort(arr):
    for i in range(len(arr)):
        preIndex = i-1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex+1] = arr[preIndex]
            preIndex-=1
        arr[preIndex+1] = current
    return arr

//C
void insertion_sort(int arr[], int len){
   
    int i,j,key;
    for (i=1;i<len;i++){
   
        key = arr[i];
        j=i-1;
        while((j>=0) && (arr[j]>key)) {
   
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
    }
}

//C++
void insertion_sort(int arr[],int len){
   
    for(int i=1;i<len;i++){
   
        int key=arr[i];
        int j=i-1;
        while((j>=0) && (key<arr[j])){
   
            arr[j+1]=arr[j];
            j--;
        }
        arr[j+1]=key;
    }
}

---

参考MOOC浙大数据结构

void InsertionSort( ElementType A[], int N ){
   
     int P, i;
     ElementType Tmp;
      
     for ( P=1; P<N; P++ ) {
   
         Tmp = A[P];
         for ( i=P; i>0 && A[i-1]>Tmp; i-- )
             A[i] = A[i-1];
         A[i] = Tmp;
     }
}

4、希尔排序

描述：

把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

动图演示：

希尔排序是基于插入排序进行改进的，（改完确实快了好多啊，以前是老黄牛，现在是小摩托了）

代码：

#python
def shellSort(arr):
    import math
    gap=1
    while(gap < len(arr)/3):
        gap = gap*3+1
    while gap > 0:
        for i in range(gap,len(arr)):
            temp = arr[i]
            j = i-gap
            while j >=0 and arr[j] > temp:
                arr