算法分类
- 非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。
- 线性时间比较类排序：不通过比较来决定元素间的相对次序，可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间比较类排序。
算法时间复杂度分析
相关概念:
- 稳定：如果a原本在b前面，而a=b，经过排序后，a仍然在b前面。
- 不稳定：如果a原本在b前面，而a=b，经过排序后，a可能b后面。
冒泡排序：
算法描述：
- 比较相邻的元素，如果第一个比第二个大，交换这两个元素；
- 对每一对相邻的元素做同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个元素；
- 重复1-3的步骤，直到排序完成。
相关代码：
void BubbleSort(vector<int>&nums) {
if (nums.empty()) {
return;
}
int temp;
int len = nums.size();
for (int j = 0; j < len - 1; j++){
for (int k = 0; k < len - 1 - j; k++){
if (nums[k] > nums[k + 1]){
temp = nums[k];
nums[k] = nums[k + 1];
nums[k + 1] = temp;
}
}
}
}
选择排序
选择排序是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
算法描述：
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。
- 初始状态：无序区为R[1…n]，有序区为空；
- 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n)。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
- n-1趟结束，数组有序化了。
相关代码：
void SelectSort(vector<int>&nums) {
if (nums.empty()) {
return;
}
int mix, temp;
int len = nums.size();
for (int i = 0; i < len - 1; i++){ //每次循环数组，找出最小的元素，放在前面，前面的即为排序好的
mix = i; //假设最小元素的下标
for (int j = i + 1; j < len; j++) //将上面假设的最小元素与数组比较，交换出最小的元素的下标
if (nums[j] < nums[mix])
mix = j;
//若数组中真的有比假设的元素还小，就交换
if (i != mix){
temp = nums[i];
nums[i] = nums[mix];
nums[mix] = temp;
}
}
}
选择排序是表现最稳定的排序算法之一，因为无论什么数据进去都是O(n^2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。
插入排序
插入排序的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
算法描述：
- 从第一个元素开始，该元素可以认为已经是排好序的；
- 取出下一个元素，在已经排序的数组序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到改位置；
- 重复步骤2-5，直到数组遍历完。
相关代码：
void InsertionSort(vector<int>&nums) {
if (nums.empty()) {
return;
}
int len = nums.size();
int preIndex, cur;
for (int i = 1; i < len; i++) {
preIndex = i - 1;
cur = nums[i];
while (preIndex >= 0 && nums[preIndex] > cur) {
nums[preIndex + 1] = nums[preIndex];
preIndex--;
}
nums[preIndex + 1] = cur;
}
}
希尔排序
希尔排序是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
算法描述：
- 选择一个增量序列t1,t2,…,tk,其中序列的最小值为1；
- 按照增量序列的个数k，对序列进行k趟排序；
- 每趟排序，根据对应的增量t，将待排序的序列分割成若干长度为m的子序列，分别对各子序列进行直接插入排序，仅增量为1的时候，整个序列作为一个整体来处理。
相关代码：
void ShellSort(vector<int>&nums) {
if (nums.empty()) {
return;
}
int len = nums.size();
int temp;
//这里设置刚开始的增量为数组长度的一半
//gap可调节
for (int gap = len / 2; gap > 0; gap = gap / 2) {
for (int i = gap; i < len; i++) {
temp = nums[i];
int j;//直接插入排序
for (j = i - gap; j > 0 && nums[j] > temp; j -= gap) {
nums[j + gap] = nums[j];
}
nums[j + gap] = temp;
}
}
}
希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。动态定义间隔序列的算法是《算法（第4版）》的合著者Robert Sedgewick提出的。
归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
算法描述：
- 把长度为n的输入序列分为两个长度为n/2的子序列；
- 对这两个序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列。
相关代码：
void MergeSort(vector<int>&nums, int left, int right) {//采用自上而下的递归
if (nums.empty()|| left >= right) {
return;
}
int len = nums.size();
int mid = (right - left) / 2 + left;
MergeSort(nums, left, mid);
MergeSort(nums, mid + 1, right);
Merge(nums, left, mid, right);
}
void Merge(vector<int>&nums, int left, int mid, int right) {
vector<int> temp(right - left + 1);//开辟一个新的数组，将原数组映射进去
for (int m = left; m <= right; m++){
temp[m - left] = nums[m];
}
int i = left, j = mid + 1;//i和j分别指向两个子数组开头部分
for (int k = left; k <= right; k++){
if (i > mid){
nums[k] = temp[j - left];
j++;
}
else if (j > right){
nums[k] = temp[i - left];
i++;
}
else if (temp[i - left] < temp[j - left]){
nums[k] = temp[i - left];
i++;
}
else{
nums[k] = temp[j - left];
j++;
}
}
}
快速排序
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
算法描述：
- 从数组中挑出一个元素，称为基准元素；
- 重新排序数组，所有元素比基准值小的摆放在基准元素前面，所有元素比基准值大的摆放在基准元素后面。
- 递归地将小于基准元素的子数组和大于基准元素的子数组排序。
相关代码：
void QuickSort(vector<int>&nums, int left, int right){
if (left < right){
int pos = Partition(nums, left, right);
QuickSort(nums, left, pos - 1);
QuickSort(nums, pos + 1, right);
}
}
int Partition(vector<int>&a, int left, int right){
int temp = a[left];
while (right > left){
while (left < right&&a[right] >= temp){
right--;
}
a[left] = a[right];
while (left < right&&a[left] <= temp){
left++;
}
a[right] = a[left];
}
a[right] = temp;
return left;
}
堆排序
堆排序是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
算法思想：
- 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
- 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
- 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)；
- 不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
注意点：
- 如果数组下标从1开始存储，编号为i的节点的主要关系为：
双亲:i/2，取下整。左孩子：2i，右孩子：2i+1。 - 如果数组下标从0开始存储，编号为i的节点的主要关系为：
双亲:(i-1)/2，取下整。左孩子：2i+1，右孩子：2i+2。
相关代码：
void HeapSort(vector<int>&nums, int n){
int i;
//首先将无序数列转换为大顶堆
for (i = n / 2; i > 0; i--) //注意由于是完全二叉树，所以我们从一半向前构造，传入父节点
AdjustHeap(nums, i, n);
//上面大顶堆已经构造完成，我们现在需要排序，每次将最大的元素放入最后
//然后将剩余元素重新构造大顶堆，将最大元素放在剩余最后
for (i = n; i > 1; i--){
Swap(nums, 1, i);
AdjustHeap(nums, 1, i - 1);
}
}
void Swap(vector<int>&nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
//大顶堆的构造，传入的i是父节点
void AdjustHeap(vector<int> &nums, int p, int n){
int i, temp;
temp = nums[p];
for (i = 2 * p; i <= n; i *= 2) { //逐渐去找左右孩子结点
//找到两个孩子结点中最大的
if (i < n&&nums[i] < nums[i + 1])
i++;
//父节点和孩子最大的进行判断，调整，变为最大堆
if (temp >= nums[i])
break;
//将父节点数据变为最大的，将原来的数据还是放在temp中，
nums[p] = nums[i]; //若是孩子结点的数据更大，我们会将数据上移，为他插入的点提供位置
p = i;
}
//当我们在for循环中找到了p子树中，满足条件的点，我们就加入数据到该点p,注意：p点原来数据已经被上移动了
//若没有找到，就是相当于对其值不变
//插入
nums[p] = temp;
}
以上算法都是非线性时间比较类排序算法，下篇再来总结线性时间比较类排序算法。
324
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
