0 常见排序算法总结
基础排序算法: 冒泡排序、选择排序、插入排序、归并排序、希尔排序、快速排序、堆排序
建议看不懂原理说明或图示时请看代码。
1.1 基本思想
冒泡排序是一种交换排序,它的基本思想是:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止。
算法描述:
1.2 图解
1.3 代码
/*1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。2. 对第0个到第n-1个数据做同样的工作。这时,最大的数就“浮”到了数组最后的位置上。3. 针对所有的元素重复以上的步骤,除了最后已经选出的元素(有序)。4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较.
*/
// 稳定排序,平均 O(n**2),最好 O(n), 最差 O(n**2),辅助空间 O(1)
void BubbleSort(vector<int> &nums)
{int n &#61; nums.size();if (n&#61;&#61;0) return;for (int i&#61;0;i<n;i&#43;&#43;){for (int j&#61;0;j<n-1-i;j&#43;&#43;){if (nums[j] > nums[j&#43;1]){// swap(nums[j], nums[j&#43;1]);int temp &#61; nums[j];nums[j] &#61; nums[j&#43;1];nums[j&#43;1] &#61; temp;}}}
}
需要C/C&#43;&#43; Linux服务器架构师学习资料加qun&#xff08;812855908&#xff09;获取&#xff08;资料包括C/C&#43;&#43;&#xff0c;Linux&#xff0c;golang技术&#xff0c;Nginx&#xff0c;ZeroMQ&#xff0c;MySQL&#xff0c;Redis&#xff0c;fastdfs&#xff0c;MongoDB&#xff0c;ZK&#xff0c;流媒体&#xff0c;CDN&#xff0c;P2P&#xff0c;K8S&#xff0c;Docker&#xff0c;TCP/IP&#xff0c;协程&#xff0c;DPDK&#xff0c;ffmpeg等&#xff09;&#xff0c;免费分享
2.1 基本思想
选择排序&#xff08;Select Sort&#xff09; 是直观的排序&#xff0c;通过确定一个 Key 最大或最小值&#xff0c;再从带排序的的数中找出最大或最小的交换到对应位置。再选择次之。双重循环时间复杂度为 O(n^2)
算法描述&#xff1a;
2.2 图解
2.3 代码
/*1. 在未排序序列中找到最小&#xff08;大&#xff09;元素&#xff0c;存放到排序序列的起始位置。2. 再从剩余未排序元素中继续寻找最小&#xff08;大&#xff09;元素&#xff0c;然后放到已排序序列的末尾。3. 以此类推&#xff0c;直到所有元素均排序完毕。
*/
// 不稳定排序&#xff0c;平均 O(n**2)&#xff0c;最好 O(n**2), 最差 O(n**2),辅助空间 O(1)
void SelectSort(vector<int> &nums)
{int n &#61; nums.size();if (n&#61;&#61;0) return;for (int i&#61;0;i<n-1;i&#43;&#43;){int idx &#61; i; //每一趟循环比较时&#xff0c;idx用于存放较小元素的数组下标&#xff0c;这样当前批次比较完毕最终存放的就是此趟内最小的元素的下标&#xff0c;避免每次遇到较小元素都要进行交换。for (int j&#61;i&#43;1;j<n;j&#43;&#43;){if (nums[idx] > nums[j]);{idx &#61; j;}}if (idx !&#61;i){int temp &#61; nums[idx];nums[idx] &#61; nums[i];nums[i] &#61; temp;}}
}
3.1 基本思想
将一个数插入一个已经排好序的数据中。
3.2 图解
3.3 代码
/*直接插入排序基本思想是每一步将一个待排序的记录&#xff0c;插入到前面已经排好序的有序序列中去&#xff0c;直到插完所有元素为止。1. 从第一个元素开始&#xff0c;该元素可以认为已经被排序2. 取出下一个元素&#xff0c;在已经排序的元素序列中从后向前扫描3. 如果被扫描的元素&#xff08;已排序&#xff09;大于新元素&#xff0c;将该元素后移一位4. 重复步骤3&#xff0c;直到找到已排序的元素小于或者等于新元素的位置5. 将新元素插入到该位置后6. 重复步骤2~5
*/
// 稳定排序&#xff0c;平均 O(n**2)&#xff0c;最好 O(n), 最差 O(n**2),辅助空间 O(1)
void InsertSort(vector<int> &nums)
{int n &#61; nums.size();if (n&#61;&#61;0) return;// 从下标为1的元素开始选择合适的位置插入&#xff0c;因为下标为0的只有一个元素&#xff0c;默认是有序的for (int i&#61;1;i<n;i&#43;&#43;){// 记录要插入的数据int temp &#61; nums[i];int j &#61; i- 1;//与已排序的数逐一比较&#xff0c;大于temp时&#xff0c;该数移后while (j>&#61;0) && (temp < nums[j]){nums[j&#43;1] &#61; nums[j];j--;}nums[j&#43;1] &#61; temp;}
}
4.1 基本思想
归并排序的主要思想是分治法。主要过程是&#xff1a;
4.2 图解
4.3 代码
/*将已有序的子序列合并&#xff0c;得到完全有序的序列&#xff1b;即先使每个子序列有序&#xff0c;再使子序列段间有序。若将两个有序表合并成一个有序表&#xff0c;称为二路归并。归并排序是一种稳定的排序方法。1、确定数组的大小&#xff0c;以及输入数组中的元素值&#xff1b;
2、将输入的数组进行分组归并&#xff1b;
3、将整个数组分成左右两个数组&#xff0c;左右两个数组再向下分&#xff0c;直至子数组的元素少于2个时&#xff0c;子数组将停止分割&#xff1b;
4、当左右子数组不能再分割&#xff0c;也是都是一个元素时&#xff0c;比较他们的大小&#xff0c;进行排序合并&#xff1b;
5、再排序合并上一级子数组为两个元素的数组&#xff0c;接着再排序合并上一级子数组为四个元素的数组&#xff1b;直至到排序合并刚开始的两个子数组&#xff0c;最后成为拍好序的数组&#xff1b;
*/
// 稳定排序&#xff0c;平均 O(nlogn)&#xff0c;最好 O(nlogn), 最差 O(nlogn),辅助空间 O(n)
void merge(int array[],int first,int last)
{int temp[last&#43;1];int mid&#61;(first&#43;last)/2;int i&#61;0; //临时数组指针int l&#61;first;//左序列指针int r&#61;mid&#43;1;//右序列指针while(l<&#61;mid&&r<&#61;last)//sort the ele of the left array and the right array{if(array[l]<array[r])temp[i&#43;&#43;]&#61;array[l&#43;&#43;];elsetemp[i&#43;&#43;]&#61;array[r&#43;&#43;];}while(l<&#61;mid) //将左边剩余元素填充进temp中{temp[i&#43;&#43;]&#61;array[l&#43;&#43;];}while(r<&#61;last) //将右序列剩余元素填充进temp中{temp[i&#43;&#43;]&#61;array[r&#43;&#43;];}i&#61;0;//将temp中的元素全部拷贝到原数组中while(first<&#61;last){array[first&#43;&#43;]&#61;temp[i&#43;&#43;];}
}
void mergesort(int data[],int first,int last)
{if(first<last){int mid&#61;(first&#43;last)/2;mergesort(data,first,mid); //左边归并排序&#xff0c;使得左子序列有序mergesort(data,mid&#43;1,last); //右边归并排序&#xff0c;使得右子序列有序merge(data,first,last); //将两个有序子数组合并操作}
}
5.1 基本思想
希尔排序&#xff0c;也被称为递减增量排序&#xff0c;是简单插入排序的一种改进版本。
• 在插入排序中&#xff0c;如果待排序列中的某个元素&#xff0c;距离有序数列中待插入位置非常远&#xff0c;就需要比较很多次才可以到达插入位置&#xff0c;这是因为待插入元素局部非常无序&#xff0c;比如说[2, 3, 4, 5, 6, 7, 8, 1, …]&#xff0c;我们要插入1&#xff0c;就必须将1和前面的2-8每个值都比较一下&#xff0c;就是因为1附近非常无序&#xff0c;想象一下&#xff0c;如果待插入元素附近比较有序&#xff0c;那么在进行插入排序的时候就只需要比较非常少的几次就可以插入到正确位置。
• 希尔排序就是先把整个序列排得相对比较有序&#xff0c;再进行插入排序的时候&#xff0c;需要比较的次数就会变得很少。
• 插入排序的增量(间隔)为1&#xff0c;希尔排序相当于将这个间隔从最大为数组长度的一半一直降到1&#xff0c;这一点在程序中体现的很清楚。当间隔很大时&#xff0c;比较的次数也会很少&#xff0c;在进行了几次大间隔的插入排序后&#xff0c;序列已经部分有序&#xff0c;这样再进行小间隔的插入排序也自然会比较很少的次数。
• 希尔排序就是将处在相同间隔的元素提取出来单独进行插入排序&#xff0c;然后逐步将间隔减小到1的过程。
5.2 图解
5.3 代码
/*数组列在一个表中并对列分别进行插入排序&#xff0c;重复这过程&#xff0c;不过每次用更长的列&#xff08;步长更长了&#xff0c;列数更少了&#xff09;来进行。
*/
// 不稳定排序&#xff0c;平均 O(nlogn)-O(n^2)&#xff0c;最好 O(nlogn), 最差 O(n**2),辅助空间 O(1)
void ShellSort(int a[],size_t n)
{int i,j,k,group;for (group &#61; n/2; group > 0; group /&#61; 2)//增量序列为n/2,n/4....直到1{for (i &#61; 0; i < group; &#43;&#43;i){for (j &#61; i&#43;group; j < n; j &#43;&#61; group){//对每个分组进行插入排序if (a[j - group] > a[j]){int temp &#61; a[j];k &#61; j - group;while (k>&#61;0 && a[k]>temp){a[k&#43;group] &#61; a[k];k -&#61; group;}a[k] &#61; temp;}}}}
}
6.1 基本思想
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分&#xff0c;其中一部分的所有数据都比另外一部分的所有数据都要小&#xff0c;然后再按此方法对这两部分数据分别进行快速排序&#xff0c;整个排序过程可以递归进行&#xff0c;以此达到整个数据变成有序序列。
主要过程&#xff1a;
6.2 图解
6.3 代码
/*1. 从数列中挑出一个元素作为基准数。2. 重新排序数列&#xff0c;将比基准数大的放到右边&#xff0c;小于或等于它的数都放到左边。3. 再对左右区间递归执行第二步&#xff0c;直至各区间只有一个数。
*/
// 不稳定排序&#xff0c;平均 O(nlogn)&#xff0c;最好 O(nlogn), 最差 O(n**2),辅助空间 O(logn)
int Paritition (int A[], int low, int high)
{int pivot &#61; A[low];while (low < high) {while (low < high && A[high] >&#61; pivot) {--high;}A[low] &#61; A[high];while (low < high && A[low] <&#61; pivot) {&#43;&#43;low;}A[high] &#61; A[low];}A[low] &#61; pivot;return low;
}
void QuickSort(int A[], int low, int high) //快排母函数
{if (low < high) {int pivot &#61; Paritition1(A, low, high);QuickSort(A, low, pivot - 1);QuickSort(A, pivot &#43; 1, high);}
}
精简版
void QuickSort(vector<int> &nums, int low, int high)
{if(low < high){int l &#61; low, r &#61; high, pivot &#61; nums[low];while(l<r){while(l<r && nums[r] >&#61;pivot) // 从右向左找第一个小于基准的数{r--;}nums[l] &#61; nums[r];while(l<r && nums[l] < pivot) // 从左向右找第一个大于等于基准的数{l&#43;&#43;;}nums[r] &#61; nums[l];}nums[l] &#61; pivot;quick_sort(nums, low, l-1);quick_sort(nums, l&#43;1, high);}
}
7.1 基本思想
堆排序(Heapsort)是指利用堆积树&#xff08;堆&#xff09;这种数据结构所设计的一种排序算法&#xff0c;它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆&#xff0c;是完全二叉树。
• 完全二叉树&#xff1a;除了最后一层之外的其他每一层都被完全填充&#xff0c;每一层从左到右的填充数据&#xff0c;不能空缺
• 大根堆&#xff1a;任意一个节点的值均大于等于它的左右孩子的值&#xff0c;位于堆顶的节点值最大
• 小根堆&#xff1a;任意一个节点的值均小于等于它的左右孩子的值&#xff0c;位于堆顶的节点值最小
堆排序的基本思想是&#xff1a;将待排序序列构造成一个大顶堆&#xff0c;此时&#xff0c;整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换&#xff0c;此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆&#xff0c;这样会得到n个元素的次小值。如此反复执行&#xff0c;便能得到一个有序序列了
7.2 图解
7.3 代码
/*
堆排序的基本思想是&#xff1a;将待排序序列构造成一个大顶堆&#xff0c;此时&#xff0c;整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换&#xff0c;此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆&#xff0c;这样会得到n个元素的次小值。如此反复执行&#xff0c;便能得到一个有序序列了
1.将无需序列构建成一个堆&#xff0c;根据升序降序需求选择大顶堆或小顶堆;
2.将堆顶元素与末尾元素交换&#xff0c;将最大元素"沉"到数组末端;
3.重新调整结构&#xff0c;使其满足堆定义&#xff0c;然后继续交换堆顶元素与当前末尾元素&#xff0c;反复执行调整&#43;交换步骤&#xff0c;直到整个序列有序。
*/
// 不稳定排序&#xff0c;平均 O(nlogn)&#xff0c;最好 O(nlogn), 最差 O(n**2),辅助空间 O(1)
void adjustHeap(int nums[],int i,int length)
{int temp &#61; arr[i];//先取出当前元素ifor(int k&#61;i*2&#43;1;k<length;k&#61;k*2&#43;1) //从i结点的左子结点开始&#xff0c;也就是2i&#43;1处开始{if(k&#43;1<length && arr[k]<arr[k&#43;1]) //如果左子结点小于右子结点&#xff0c;k指向右子结点{k&#43;&#43;;}if(arr[k] >temp) //如果子节点大于父节点&#xff0c;将子节点值赋给父节点&#xff08;不用进行交换&#xff09;{ arr[i] &#61; arr[k];i &#61; k;}else{break;}}arr[i] &#61; temp; //将temp值放到最终的位置
}
void HeapSort(int nums[],int len)
{//1.构建大顶堆for(int i&#61;len/2-1;i>&#61;0;i--){//从第一个非叶子结点从下至上&#xff0c;从右至左调整结构adjustHeap(nums,i,len);}//2.调整堆结构&#43;交换堆顶元素与末尾元素for(int j&#61;len-1;j>0;j--){swap(nums[0],nums[j]);//将堆顶元素(最大值)与末尾元素进行交换&#xff0c;将最大值交换到数组的最后位置保存adjustHeap(nums,0,j);//重新对堆进行调整}
}