七大排序
- 插入排序
- 选择排序
- 未优化前版本
- 优化版本
- 冒泡排序
- 归并排序
- 快速排序
- 堆排序
- 计数排序
- 稳定性的概念
- 总结
插入排序
什么是插入排序？
指的是当插入第n个元素时，之前的n-1个元素已经有序了，将第n个元素和前面的n-1个元素比较，找到适合插入的位置，插入点后面的元素都向后挪动一个位置，空出来的位置直接插入即可。
时间复杂度：
最坏的情况下，每次插入一个元素，都需要挪动全部元素，故有1+2+3+…+n=n*(n+1)/2。即为O(n^2)
空间复杂度：
在原有的数组挪动即可，不需要额外的空间。O(1)
稳定性：稳定的。
例子：
待插入元素：5 2 3 6 1 4 8
第一次插入：5
第二次插入：2 5（5需要向后挪动）
第三次插入：2 3 5（5需要向后挪动）
第四次插入：2 3 5 6（直接插入，不需要挪动）
第五次插入：1 2 3 5 6（2 之后的所有元素都向后挪动）
第六次插入：1 2 3 4 5 6（5和6向后挪动）
第七次插入：1 2 3 4 5 6 8（直接插入，不需要挪动）
完整代码：
#include <iostream>
using namespace std;
//插入排序(升序)
/*
1、当插入第n个元素时，前面的n-1个数已经有序
2、用这第n个数与前面的n-1个数比较，找到要插入的位置，将其插入（原来位置上的数不会被覆盖，因为提前保存了）
3、原来位置上的数据，依次后移
时间复杂度:O(N^2) :
最坏的情况下，每次插入一个数字，
前面的数字都要挪动一下，一共需要挪动1+2+3+……+n=n(n+1)/2
空间复杂度：O(1)
*/
void insertSort(int arr[],int len)
{
for (int i = 0;i < len;i++)
{
int moveValue = arr[i];
int j;
//找到合适插入的位置
for (j = i-1;j >= 0;j--)
{
// > 为降序 ， < 为升序
if (moveValue < arr[j])
{
arr[j + 1] = arr[j];
}
else
{
break;
}
}
arr[j + 1] = moveValue;
}
}
int main()
{
int arry[10] = { 5,2,6,4,8,7,1,9,4,8 };
cout << "排序前的元素：" << endl;
for (int i = 0;i < 10;i++)
{
cout << arry[i] << " ";
}
cout << endl;
cout << "排序后的元素：" << endl;
insertSort(arry, 10);
for (int i = 0; i < 10;i++)
{
cout << arry[i] << " ";
}
return 0;
}
选择排序
什么是选择排序？
指的是对数组遍历一遍，找出最大值或最小值的下标，放到已排序好的元素后面，不断重复该操作。
时间复杂度：
每次插入元素前，都需要遍历数组查找最大值或最小值的下标。故O(n^2)
空间复杂度：
不需要额外的空间。O(1)
稳定性：不稳定的。
未优化前版本
#include <iostream>
#include <algorithm>
using namespace std;
//升序
void selectSort(int* arr, int len)
{
for (int i = 0;i < len;i++)
{
int minValue = INT_MAX;
int minIndx = i;
for (int j = i;j < len;j++)
{
if (minValue > arr[j])
{
minIndx = j;
minValue = arr[j];
}
}
//将最小值或最大值插入到已经排序好元素的后面
int temp = arr[minIndx];
arr[minIndx] = arr[i];
arr[i] = temp;
}
}
int main()
{
int arry[] = { 4,7,2,3,6,8,4,1 };
selectSort(arry, 8);
for (int i = 0;i < 8;i++)
cout << arry[i] << " ";
return 0;
}
优化版本
遍历数组时同时查找最小值和最大值。
#include <iostream>
#include <algorithm>
using namespace std;
/*
时间复杂度：O(N^2)
空间复杂度：O(1)
*/
//选择排序
void selectSort(int arr[],int len)
{
int minv , maxv;
for (int begin = 0,end=len-1;begin <= end;begin++, end--)
{
minv = INT_MAX, maxv = INT_MIN;
int maxIndx = end, minIndx = begin;
//同时查找最小值和最大值
for (int j = begin;j <= end;j++)
{
if (maxv < arr[j])
{
maxIndx = j;
maxv = arr[j];
}
if (minv > arr[j])
{
minIndx = j;
minv = arr[j];
}
}
//如果begin的下标刚好是maxIndx，则第一次交换后arr[maxIndx]对应的值发生了改变了
if (begin == maxIndx)
{
maxIndx = minIndx;
}
int temp = arr[begin];
arr[begin] = arr[minIndx];
arr[minIndx] = temp;
temp = arr[end];
arr[end] = arr[maxIndx];
arr[maxIndx] = temp;
}
}
int main()
{
int arry[] = { 4,7,2,3,6,8,4,1 };
selectSort(arry, 8);
for (int i = 0;i < 8;i++)
cout << arry[i] << " ";
return 0;
}
冒泡排序
什么是冒泡排序？
对未排序的数组遍历一次，不断比较交换，得到一个最大值或最小值放到未排序数组的尾部。重复地执行此操作，直到全部有序。
时间复杂度O(n^2)
空间复杂度O(1)
稳定性：稳定的。
例子：
arr[] = {5,2,3,1,9,7,4}
//不断比较交换，将最大值放到数组最后面，此轮是9在最后面
//该数组未排序的元素长度-1
第一轮：2，3，1，5，7，4，9
//此轮最大值为7
第二轮：2，1，3，5，4，7，9
//此轮最大值为5，发现好像全部有序了，优化思路：当已经有序终止排序
第三轮：1，2，3，4，5，7，9
完整代码：
//冒泡排序
void mSort(vector<int>& arr)
{
int m = arr.size();
//用于判断是否交换过，若没有则证明已经有序
bool isChanged = false;
for(int i=0;i<m;i++)
{
for(int j=1;j<m-i;j++)
{
if(arr[j] < arr[j-1])
{
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
isChanged = true;
}
}
if(isChanged) break;
}
}
归并排序
什么是归并排序?
将数组平均划分为若干个区间数组，分别对区间的元素排序，最后再合并。
时间复杂度O(nlogn)
空间复杂度O(n)
稳定性：稳定的。
例子：
arr[] = {5,2,3,1,9,7,4}
将数组划分为{5，2，3，1} 和 {9，7，4}
然后继续将{5，2，3，1}均分为 {5，2} 和 {3，1}
{9，7，4}均分为{9，7} 和{4}
最后{5，2}和{3，1}、{9，7}继续划分为
{5}、{2}，{3}，{1}，{9}，{7}
划分到子数组只有一个元素后，默认该数组有序了，接下来是合并子数组
{5}和{2}合并，变为{2，5}
{3}和{1}合并，变为{1，3}
{9}和{7}合并，变为{7，9}
继续向上合并
{2，5}和{1，3}合并，变为{1，2，3，5}
{7，9}和{4}合并，变为{4，7，9}
最后合并
{1，2，3，5} 和 {4，7，9}合并，变为{1，2，3，4，5，7，9}
完整代码：
void _margeSort(vector<int>& arr,int left,int right,vector<int>& temp)
{
if(left >= right) return ;
int mid = (right + left) /2;
_margeSort(arr, left, mid ,temp);
_margeSort(arr, mid+1, right ,temp);
int begin1 = left , end1 = mid;
int begin2 = mid+1 , end2 = right;
int indx = left;
while(begin1 <= end1 && begin2 <= end2)
{
if(arr[begin1] > arr[begin2])
{
temp[indx++] = arr[begin2++];
}
else
{
temp[indx++] = arr[begin1++];
}
}
while(begin1 <= end1) temp[indx++] = arr[begin1++];
while(begin2 <= end2) temp[indx++] = arr[begin2++];
for(int i=left;i<=right;i++)
arr[i] = temp[i];
}
//归并排序
void margeSort(vector<int>& arr)
{
//需要额外的辅助空间
vector<int> temp = arr;
_margeSort(arr,0,arr.size()-1,temp);
}
快速排序
什么是快速排序？
从数组中选取一个元素作为基点，以这个基点为中心，将数组右边元素都大于该基点，左边元素都小于该基点。不断重复此操作，直到元素全部有序。
时间复杂度O(nlogn)
空间复杂度O(1)
稳定性：不稳定的。
完整代码：
//此处是“挖坑法”
//意思是选取基点后，将基点从数组中挖去，留下一个坑位置
//然后从右到左找到第一个小于基点的值，放入到坑位置，而形成新的坑
//之后从左到右找到第一个大于基点的值，放入到坑位置，而形成新的坑
//重复以上操作，直到右边都大于基点，左边都小于基点
//最后将基点放入到坑的位置
//返回最后的坑的位置
int _quickSort(vector<int>& arr,int left,int right)
{
//随机基点，避免数组已经有序，提高效率
int randix = rand()%(right - left) + left;
swap(arr[randix] , arr[left]);
int key = arr[left];
while(left < right)
{
while(left < right && arr[right] >= key) right--;
arr[left] = arr[right];
while(left < right && arr[left] <= key) left++;
arr[right] = arr[left];
}
arr[left] = key;
return left;
}
//快速排序
void quickSort(vector<int>& arr,int left , int right)
{
if(left >= right) return ;
//返回一个基点位置，该基点左边元素都已经小于它，右边大于它了
int key = _quickSort(arr, left , right);
//对基点左边的区间重复以上操作
quickSort(arr, left , key-1);
//对基点右边的区间重复以上操作
quickSort(arr, key+1 , right);
}
堆排序
堆是一种完全二叉树，完全二叉树的非叶子节点个数 <= 叶子节点个数（最多比叶子节点个数+1），故设该数的总节点个数为n，那么最后一个非叶子节点位置 = n/2-1。
当一个非叶子节点位置为 k 时，那么它的左右节点位置为：
left = 2k + 1 ， right = 2k + 2
时间复杂度O(nlogn)
空间复杂度O(1)
稳定性：不稳定的。
完整代码：
void _adjust(vector<int>& arr,int size,int indx)
{
//找到该节点的左右子节点
int left = 2*indx + 1;
int right = 2*indx + 2;
int maxindx = indx;
if(left < size && arr[left] > arr[maxindx]) maxindx = left;
if(right < size && arr[right] > arr[maxindx]) maxindx = right;
if(maxindx != indx)
{
swap(arr[maxindx] , arr[indx]);
//向下调整堆
_adjust(arr, size , maxindx);
}
}
//堆排序
void heapSort(vector<int>& arr)
{
int size = arr.size();
//初始化大根堆,从最后一个非叶子节点开始，而size/2-1正是最后一个非叶子节点的下标
//堆是一个完全二叉树，它的非叶子节点个数 <= 叶子节点（要么==。要么+1）
for(int i=size/2-1; i >=0 ;i--)
{
_adjust(arr , size , i);
}
//将堆根节点 和 堆尾 交换，使得每一轮的最大值放在了堆后面
for(int i=size-1;i>=0;i--)
{
swap(arr[0] , arr[i]);
//向下调整堆，注意：该调整堆的大小要-1，从堆的根节点向下调整
_adjust(arr , i , 0);
}
}
计数排序
什么是计数排序？
它是以空间换时间，时间复杂度为O(n+k)，n为数组的总个数，k为某元素在数组中出现的次数。
它的适应范围：要求数组的每个元素是在[0,n]范围内的整数，当数组有负数时，可以将它整个数组的元素 + （最小负数的反数），使得数组的最小值为0。
时间复杂度为O(n+k)
它是稳定性的。
完整代码：
#include <iostream>
using namespace std;
//计数排序
void CountSort(int arr[], int len)
{
int max = INT_MIN, min = INT_MAX;
//找出数组中最大和最小值
for (int i = 0;i < len;i++)
{
max = max < arr[i] ? arr[i] : max;
min = min > arr[i] ? arr[i] : min;
}
//计数数组的大小
int size = max - min + 1;
int *countArry = (int*)malloc(sizeof(int)*size);
memset(countArry, 0, size*sizeof(int));
//记录arr[]中的每个元素出现的个数
for (int i = 0;i < len;i++)
{
countArry[arr[i] - min]++;
}
int j = 0;
//复制到原数组中
for (int i = 0;i < size;i++)
{
while (countArry[i]--)
{
arr[j++] = i + min;
}
}
free(countArry);
countArry = NULL;
}
int main()
{
int arr[] = { 5,2,6,8,3,4,1,7 };
CountSort(arr, 8);
for (int i = 0;i < 8;i++)
{
cout << arr[i] << " ";
}
return 0;
}
稳定性的概念
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，A1=A2，且A1在A2之前，而在排序后的序列中，A1仍在A2之前，则称这种排序算法是稳定的；否则称为不稳定的。
总结
常见算法的稳定性（要记住）
不稳定排序算法
堆排序、快速排序、希尔排序、直接选择排序
稳定排序算法
基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序
6718
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
