八大经典排序算法
Posted TangguTae
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了八大经典排序算法相关的知识,希望对你有一定的参考价值。
目录
常见的八种排序算法:插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
插入排序
思想:每一步将一个待排序的数据插入到前面已经排好序的有序序列中,直到插完所有元素为止。
当在玩扑克牌整理牌的时候,其实就用到了插入排序的思想。
具体代码实现
void InsertSort(int* const arr, const int len)
assert(arr);
for (int i = 0; i < len; i++)//遍历每个元素
for (int j = i; j > 0; j--)//与前面的元素相比较
if (arr[j] < arr[j - 1])
swap(arr + j, arr + j - 1);
else //已经有序
break;
复杂度分析:
时间复杂度O(N^2),空间复杂度O(1)
插入排序是一种稳定的排序算法,当元素集合越接近有序,直接插入排序算法的时间效率越高。
希尔排序
希尔排序也叫缩小增量排序,本质上是对插入排序的优化(利用插入排序当元素集合越接近有序,插入排序算法效率更高的特点)。
思想:对待排序数组中的元素进行分组,从第一个元素开始,按照数组下标中间隔为gap大小的元素分为一组,对每一组进行排序,重新选择gap的大小使得原始数据更加有序,当gap=1的时候就是插入排序。
void ShellSort(int* const arr, const int len)
int gap = len;
while (gap > 1)
gap = gap / 3 + 1;//调整gap的大小,gap=1的时候,为插入排序
for (int i = gap; i < len; i++)//总共只需要循环len-gap次
for (int j = i; j >= 0; j--)//插入排序
if (arr[j] < arr[j - gap])
swap(arr + j, arr + j - gap);
else
break;
注意:这里的分组比较不是分开进行的(第一组比完第二组在比),而是多组同时进行比较,从第gap个元素开始,逐渐往前比较,每次和自己和自己gap距离的元素比较
复杂度分析:O(N^1.3 - N^2)
稳定性:不稳定
选择排序
思想:每次选择数组元素中最小(最大)的元素放在序列的起始位置,直到全部待排序的数据元素排完。
void SelectSort(int* const arr, const int len)
for (int i = 0; i < len; i++)
int location = i;//记录最小值的位置
for (int j = i + 1; j < len; j++)
if (arr[j] < arr[location])//更新最小值的位置
location = j;
if (i != location)
swap(arr + i, arr + location);
复杂度分析:O(N^2)
稳定性:不稳定
堆排序
参考这篇文章
冒泡排序
非常经典的排序方法
思想:冒泡排序两两进行比较,遍历完一次都会把最大(小)的元素放在了后面,是一种非常容易理解的排序方法。
void BubbleSort(int* const arr, const int len)
for (int i = 1; i < len; i++)
for (int j = 0; j < len - i; j++)
if (arr[j] > arr[j + 1])
swap(arr + j, arr + j + 1);
复杂度分析:O(N^2)
稳定性:稳定
快速排序
非常重要的一个排序,出现的次数超高频!!!
以下方法讨论都是升序场景。
hoare法
思想:利用左右两个下标,分别指向头(left)和尾(right),将数组头部元素设为基准值(key),left往右走寻找比key大的值,right向左走寻找比key小的值(right先出发),双方都找到后交换left和right所指向的数组元素值,直到left和right相遇。相遇后交换key和相遇点的元素值(相遇点一定比key值小,所以需要交换值,原因right先走),这样就可以使得相遇点左边元素都比他小,右边元素都比他大。
void QuickSort(int* const arr, const int begin, const int end)
int left = begin;
int right = end;
int key_i = left;
if (begin >= end)//递归结束条件
return;
while (left < right)
//右边先走
while (left < right&&arr[right] >= arr[key_i])//找比key_i 处小的值
right--;
while (left < right&&arr[left] <= arr[key_i])//找比key_i 处大的值
left++;
swap(arr + left, arr + right);
swap(arr + key_i, arr + left);
QuickSort(arr, begin, left - 1);//递归
QuickSort(arr, right + 1, end);
复杂度分析:
快速排序的单次排序复杂度为O(N),最好的情况每次key值都在中间,总共需要递归logN次,所以整体的复杂度为O(NlogN)
最坏的情况是序列为逆序的状态,O(N^2)
稳定性:不稳定
挖坑法
整体思路还是和hoare法类似,需要使得使得相遇点左边元素都比他小,右边元素都比他大(升序)。
思想:假定有一坑hole在序列头部,坑里面的值用key来记录,现在需要把把hole给填上。同样的,先让right往右走,寻找比key值小的元素,找到以后把right里面的值填入坑hole中,这样新的hole就在right这里,然后让left往右走,寻找比key大的值,交换left和hole,直到left和right相遇在hole处,把key值填入hole里。
void QuickSort(int* const arr, const int begin, const int end)
int left = begin;
int right = end;
int key = arr[left];
int hole = left;
if (begin >= end)
return;
while (left < right)
while (left < right&&arr[right] >= key)//右边先走
right--;
arr[hole] = arr[right];//填坑
hole = right;//更新坑的位置
while (left < right&&arr[left] <= key)//左边后走
left++;
arr[hole] = arr[left];
hole = left;
arr[left] = key;
QuickSort(arr, begin, left - 1);//递归
QuickSort(arr, right + 1, end);
前后指针法
该方法相比较前面两种方法稍微难理解一点,不是很直观。
思想:定义前后两个指针prev和cur,让cur去寻找比key小的值。由于prev在cur的前面,当prev的下一个值不与cur重合时,prev的值与key的值的关系是大于等于(cur已经探寻过了,探寻过的路径只存在比key大的值,除非与prev的下一个重合),交换prev++处与cur处的值。一直迭代,直到cur走到了末尾后,交换prev和key处的值。
void QuickSort(int* const arr, const int begin, const int end)
int prev = begin;
int cur = begin + 1;
int key = begin;
if (begin >= end)
return;
while (cur <= end)
while (cur <= end && arr[cur] > arr[key])//cur去找小于key的值
cur++;
if (cur <= end)
prev++;
swap(arr + prev, arr + cur);//将prev后一个值与cur处的值交换
cur++;
swap(arr + key, arr + prev);
QuickSort(arr, begin, prev - 1);
QuickSort(arr, prev + 1, end);
快速排序的优化
由于快速排序中key值的大小会影响到整体排序的性能(主要因素),太大或者太小都会影响到快排的效率。递归的深度也会影响到快排的效率,会有较大的开销,可能会栈溢出(次要因素)。
所以可以采取以下两种方法来对快速排序进行优化
1、三数取中
选取头、中、尾三个位置的元素进行比较,选取大小在中间的值,并与首元素进行交换,然后依然按照上面流程继续排序。
目的:这样可以尽可能的避免key值过大或者过小的问题。
int GetMidIndex(int* const arr, int begin, int end)
int mid = (begin + end) >> 1;
if (arr[begin] > arr[mid])
if (arr[begin] > arr[end])
if (arr[mid] > arr[end])
return mid;
else
return end;
else
return begin;
else
if (arr[begin] < arr[end])
if (arr[end] > arr[mid])
return mid;
else
return end;
else
return begin;
所以说对于不同的方法实现的快排,只需要插入两行代码
int MidIndex = GetMidIndex(arr, left, right);//对快排的优化
swap(arr + left, arr + MidIndex);//对快排的优化
2、小区间优化
目的:减少递归的次数
思想:当递归到一定程度时,需要排序的数据量不大,我们可以采用前面所说的插入排序直接完成排序,不需要继续递归下去,数据量少时,反而相比递归效率更高。
对hoare方法优化
void QuickSort(int* const arr, const int begin, const int end)
int left = begin;
int right = end;
int key_i = left;
if (begin >= end)
return;
if (end - begin > 10)//假设数据长度小于10就直接采用插入排序,减少递归次数
while (left < right)
//右边先走
while (left < right&&arr[right] >= arr[key_i])
right--;
while (left < right&&arr[left] <= arr[key_i])
left++;
swap(arr + left, arr + right);
swap(arr + key_i, arr + left);
QuickSort(arr, begin, left - 1);
QuickSort(arr, right + 1, end);
else
InsertSort(arr + begin, end - begin + 1);
非递归实现快排
非递归实现快排需要借助其他的数据结构来实现。
利用栈来模拟递归的过程。
思路:每次分割序列后,把左右两部分序列的头和尾压入栈中,每次取出头和尾继续分割快排,直到栈中的数据全部取出。
//hoare方法
int QShoareNonR(int* const arr, const int begin, const int end)
int left = begin;
int right = end;
int key_i = left;
while (left < right)
//右边先走
while (left < right&&arr[right] >= arr[key_i])
right--;
while (left < right&&arr[left] <= arr[key_i])
left++;
swap(arr + left, arr + right);
swap(arr + key_i, arr + left);
return left;
//非递归的逻辑
void QuickSortNon(int* const arr, const int begin, const int end)
std::stack<int> st;
st.push(begin);
st.push(end);
while (!st.empty())//只要栈不为空,继续出栈
//逻辑:每次把分割后的右边先调整,最后把左边调整
//注意入栈和出栈的顺序
int right = st.top();
st.pop();
int left = st.top();
st.pop();
int meet_i = QShoareNonR(arr, left, right);
if (meet_i > left)//先入左边,左边最后调整
st.push(left);
st.push(meet_i - 1);
if (meet_i < right)
st.push(meet_i + 1);
st.push(right);
归并排序
归并算法采用非常经典的分治策略,每次把序列分成n/2的长度,将问题分解成小问题,由复杂变简单。
动画演示:
原理:先拆分,后合并
具体实现:
void _MergeSort(int* const arr, const int begin, const int end, int* const arr_tmp)
if (begin >= end)
return;
//首先先分解问题
int mid = (begin + end) >> 1;
_MergeSort(arr, begin, mid, arr_tmp);
_MergeSort(arr, mid + 1, end, arr_tmp);
//问题分解完后进行归并
int head_left = begin;
int head_right = mid + 1;
int tmp_index = begin;
while (head_left<=mid&& head_right<=end)
if (arr[head_left] < arr[head_right])//对左右两部分进行比较
arr_tmp[tmp_index++] = arr[head_left++];
else
arr_tmp[tmp_index++] = arr[head_right++];
//剩下的元素直接填充,因为有序
while (head_left <= mid)
arr_tmp[tmp_index++] = arr[head_left++];
while (head_right <= end)
arr_tmp[tmp_index++] = arr[head_right++];
//降临时创建的数组的元素拷贝给原数组
for (int i = begin; i <= end; i++)
arr[i] = arr_tmp[i];
void MergeSort(int* const arr, const int len)
int *arr_tmp = (int*)malloc(sizeof(int)*len);
_MergeSort(arr, 0, len - 1, arr_tmp);
free(arr_tmp);
复杂度:时间复杂度O(NlogN),空间复杂度O(1)。
稳定性:稳定
计数排序
本质上是一种映射的思想,和哈希有点类似。
思路:统计数组中每个元素出现的次数,初始化数组中所有元素为0,开辟一个新的数组,把待排序数组中的元素值作为下标,使新的数组在该下标下的值++。在这个统计的过程中,也就相当于对原数组的一个排序过程,统计完之后,按照顺序,出现几次,就在原数组中填几次该元素。
//计数排序
//只能是正整型
void CountSort(int* const arr, int length)
assert(arr);
//首先寻找最大值和最小值
//确定新数组的大小
int max=arr[0], min=arr[0];
for (int i = 1; i < length; i++)
if (max < arr[i])
max = arr[i];
for (int i = 1; i < length; i++)
if (min > arr[i])
min = arr[i];
int range = max - min + 1;
int* count = (int*)malloc(sizeof(int)*range);
memset(count, 0, sizeof(int)*range);//先初始化内存为零
for (int i = 0; i < length; i++)//统计每个元素出现的次数
count[arr[i]-min]++;
int j = 0;
for (int i = 0; i < range; i++)//根据统计情况,重新覆盖原来数组
while (count[i]--)
arr[j++] = min + i;
free(count);
复杂度:时间复杂度O(N+range),range为待排序序列中最大值与最小值的差值+1;
空间复杂度O(range)。
缺点:只能对正整数进行排序。
以上是关于八大经典排序算法的主要内容,如果未能解决你的问题,请参考以下文章