常用的排序算法

常用的八大排序

---

前言

基本的排序算法如下：本文重点关注的是希尔排序、堆排序、快速排序、归并排序

---

一、插入排序

直接插入排序的核心思想就是：

1. 找出元素L(i)在已排序L[1…i-1]中的插入位置k
2. 将L[k…i-1]中所有元素依次后移一位
3. 将L[i]复制到L(k)

代码实现：

void StraightSort(int A[], int n)
{
	int i,j;
    for(i=2;i<=n;i++){//从第二个数字开始迭代
        if(A[i]<A[i-1]){
            A[0]=A[i];//设置哨兵，A[0]不存放元素
            for(int j=i-1;A[0]<A[j];j--){//从后往前查找插入位置k
                A[j+1]=A[j];//向后挪位
            }
            A[j+1]=A[0];//复制到插入位置
        }
	}
}

二、希尔排序

思想：(分块直接插入排序)
将待排序分割成若干个子表，对各个子表分别进行直接插入排序，待总体“基本有序”，再进行一次全体的直接插入排序
1）先将步长dk取为n/2,然后每次迭代/2，直到dk=1时，对全体进行一次直接插入排序，算法结束
2) 距离为dk的数作为一个子表，子表内部进行直接插入排序

void ShellSort(int A[],int n){
    // A[0]只是暂存单元，不是哨兵,当j<=0时，插入位置已到
    // dk为步长
    int dk,i,j;
    for(dk=n/2;dk>=1;dk++){
        for(i=dk+1;i<=n;i++){
            if(A[i]<A[i-dk]){
                A[0]=A[i];
                for(j=i-dk;j>0&&A[0]<A[j];j-=dk)
                    A[j+dk]=A[j];
                A[j+dk]=A[0];
            }
        }
    }
}

转载-希尔排序

三、快速排序

思想：分治法

1）选择一个基准元素,通常选择第一个元素或者最后一个元素
2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

代码如下（示例）：

//思路：分治递归
// 选定一个基数x(一开始默认为数组首地址)，将数组分为前面小于x的区间和后面大于x的区间，再分别递归对
// 两个区间再进行快速排序，直到全部有序
void quickSort(int arr[],int start,int end){
    if(start<end){//递归条件
        //把数组的第一个数字作为基数
        int startnum=arr[start];
        //标记高位和低位
        int low = start;
        int high = end;
        // 循环进行排序
        while (low<high)
        {
            //高位的数如果比标准数大，则高位向左移
			while(low<high&&startnum<=arr[high]){
				high--;
			}
			//不是，则高位数与低位交换
			arr[low]=arr[high];
			//低位的数如果比标准数小，则低位右移
			while(low<high&&arr[low]<=startnum){
				low++;
			}
			//不是，则低位与高位交换
			arr[high]=arr[low];
        }
        //高低位重合，低位或者高位下标赋值，值为标准数
		arr[low]=startnum;
		//递归左半边
		quickSort(arr, start, low);
		//递归右半边
		quickSort(arr, low+1, end);
    }
}

三、堆排序

思路：构建完全二叉树，实现下沉或上升

大根堆：
1）通过数组来构建一个完全二叉树，从最后一个非叶子节点开始。如果存在子节点大于根节点，则交换两个节点的值，再递归对子节点进行调整。
2）调整完之后，将堆顶与堆底的数进行交换，size自减，再调整从0到堆底的堆，推出第二大的数至堆顶，直至结束。

时间复杂度O(nlogn) 空间复杂度O()
代码如下（示例）：

#include<bits/stdc++.h>
using namespace std;
//堆排序，本题是根据大根堆来进行排序
//该函数是构建大根堆
void print(int array[],int size){
    for(int i=0;i<size;i++){
        cout<<array[i]<<" ";
    }
    cout<<endl;
}
void maxdownheap(int array[],int i,int heapsize){
    int largest=i;//假设根节点为较大值
    int left=2*i+1,right=2*i+2;//left为左节点、right为右节点
    if(left<heapsize&&array[left]>array[largest]){
        largest=left;
    }
    if(right<heapsize&&array[right]>array[largest]){
        largest=right;
    }
    if(largest!=i){//子节点大于根节点
        swap(array[largest],array[i]);//交换
        maxdownheap(array,largest,heapsize);//继续对子节点进行调节
    }
}
void buildheap(int array[],int heapsize){
    for(int i=heapsize/2-1;i>=0;i--){//从最后一个非叶子节点开始进行构建堆
        maxdownheap(array,i,heapsize);
    }
}
int main(){
    int array[]={49, 38, 65, 97, 76, 13, 27, 49, 10};
    int size = sizeof(array) / sizeof(int);
    cout<<"before"<<endl;
    print(array,size);
    buildheap(array,size);
    for(int i=size-1;i>=0;i--){//从最后一个节点开始
        swap(array[0],array[i]);
        --size;
        maxdownheap(array,0,size);
    }
    size=sizeof(array) / sizeof(int);
    cout<<"after"<<endl;
    print(array,size);
    return 0;
}

四、归并排序

思路：还是分治法

1）先将待排序的数组不断进行递归分组，直到只剩数组中只剩一两个元素时，再对分组内的元素进行排序。
2）接着利用双指针来对划分的左右数组进行排序。判断当前左右数组的首元素哪个小，优先进入中间数组。
3）直到其中一个数组遍历完，则将另外一个数组的剩下元素存入中间数组中。
4）将中间数组中的元素排序代回到原数组中。

时间复杂度O(nlogn) 空间复杂度为O(n)
代码如下（示例）：

#include <iostream>
using namespace std;
int a[1000], b[1000];
//双指针来遍历对应的两个数组，
void Merge(int *a, int *b, int begin, int mid, int end) {
    int pb = 0;
    int p1 = begin, p2 = mid + 1;//双指针，分别指向左数组和右数组
    while (p1 <= mid && p2 <= end) {
        if (a[p1] <= a[p2])
            b[pb++] = a[p1++];
        else
            b[pb++] = a[p2++];
    }
    //当其中一个数组遍历完，则将另外数组的剩余元素存入到中间数组
    while (p1 <= mid)
        b[pb++] = a[p1++];
    while (p2 <= end)
        b[pb++] = a[p2++];
    //将中间数组排序过后的元素放入到原数组a中
    for (int i = 0; i < end - begin + 1; ++i) {
        a[begin + i] = b[i];
    }
}

void Merge_Sort(int *a, int *b, int begin, int end) {
    if (begin < end) {
        //取中间数，对左右数组进行划分
        int mid = begin + (end - begin) / 2;
        Merge_Sort(a, b, begin, mid);
        Merge_Sort(a, b, mid + 1, end);
        Merge(a, b, begin, mid, end);
    }
}

int main() {
    ios::sync_with_stdio(false);
    int n, k = 0;
    cout<<"输入你要排序的数字：";
    while (cin >> n) {
        a[k++] = n;
        if (cin.get() == '\n')   //cin输入吃到了回车就不继续读入了
            break;
    }

    cout << k << "位" << endl;
    Merge_Sort(a, b, 0, k - 1);
    for (int i = 0; i < k; ++i) {
        cout << a[i]<<" ";
    }
    return 0;
}

}

总结