浙大数据结构习题笔记：排序算法总结

排序算法总结

PS：期末复习，好久没看浙大的笔记了，习题也一直没做……后来发现排序算法上学期期末也没看，借着复习数据结构来看一下排序算法。

视频中的这张图我觉得总结的很棒，觉得考试可能会考（

总结的代码实现:

#include 
#include 
#include 
#include 

#define NUM_SIZE 20

int A[NUM_SIZE];
using namespace std;

void random()
{
    for(int i=0;i<NUM_SIZE;i++){
        A[i] = rand()%NUM_SIZE+1;
    }
}

void outPut()
{
    for(int i=0;i<NUM_SIZE;i++){
        cout<<A[i]<<" ";
    }
    cout<<endl;
}

void bubbleSort(int n)
{
    for(int p=n-1;p>=0;p--){
        //从头到尾一共n-1次冒泡
        //p后为已经排好队的元素
        bool flag = false;
        for(int j=0;j<p;j++){
            //从第一个元素到已经排好队的元素
            if(A[j+1] < A[j]){
                int temp = A[j];
                A[j] = A[j+1];
                A[j+1] = temp;
                flag = true;
            }
        }
        if(flag == false)
            break;
    }
    //O(n^2)
}

void insertSort(int A[],int n)
{
    /*插入排序：从第二个元素开始向前逐个比较，将此元素
      插入到应该存放的位置中，复杂度取决于顺序程度
      O(n)-O(n^2)*/
    for(int p=1;p<n;p++){
        int temp = A[p];
        //从第二个元素开始，抽取temp
        int j=p;
        for(;j>0 && temp <A[j-1];j--){
            A[j] = A[j-1];
            //符合——大的向右侧移动
        }
        A[j] = temp;
    }
}

void shellSort(int n)
{
    for(int D = n/2;D>0;D/=2){  //希尔增量序列
        for(int p=D;p<n;p+=D){
            int temp = A[p];
            int j=p;
            for(;j>=D && temp<A[j-D] ;j-=D){
                A[j] = A[j-D];
            }
            A[j] = temp;
        }
    }
}

//调整成最大堆
void PrecDown(int i,int n){
    int child,parent;
    int temp = A[i];
    for(parent = i;parent*2+1<=n-1;parent=child){
        child = parent*2 +1;
        if((child!=n-1) && (A[child] < A[child+1])){
            child++;
        }
        if(A[child] <= temp){
            break;
        }
        A[parent] = A[child];
    }
    A[parent] = temp;
}

void heapSort(int n)
{
    //O(nlogn)
    for(int i=n/2;i>=0;i--){
        PrecDown(i,n);
    }
    for(int i=n-1;i>0;i--){
        int temp = A[0];
        A[0] = A[i];
        A[i] = temp;
        PrecDown(0,i);
    }
}

void merge(int A[],int tempA[],int L,int R,int rightEnd)
{
    //L=左起点，R=右起点，rightEnd=右终点
    int leftEnd = R-1;
    int temp = L;
    int num = rightEnd-L+1;
    while(L<=leftEnd && R<=rightEnd){
        if(A[L] <= A[R])
            tempA[temp++] = A[L++];
        else
            tempA[temp++] = A[R++];
    }
    while(L<=leftEnd){
        tempA[temp++] = A[L++];
    }
    while(R<=rightEnd){
        tempA[temp++] = A[R++];
    }
    for(int i=0;i<num;i++,rightEnd--){
        A[rightEnd] = tempA[rightEnd];
    }
}

void mergeDivide(int A[],int tempA[],int L,int rightEnd)
{
    if(L<rightEnd){
        int center = (L+rightEnd)/2;
        mergeDivide(A,tempA,L,center);
        mergeDivide(A,tempA,center+1,rightEnd);
        merge(A,tempA,L,center+1,rightEnd);
    }
}

void mergeSortCircle(int A[],int n)
{
    int tempA[NUM_SIZE];
    mergeDivide(A,tempA,0,n-1);
}

void swap(int &a,int &b)
{
    int t = a;
    a = b;
    b = t;
}

int getPivot(int L,int R)
{
    int center = (L+R)/2;
    //排序，让center介于A[L]和A[R]之间
    if(A[R] < A[center]){
        swap(A[R],A[center]);
    }
    if(A[R] < A[L]){
        swap(A[R],A[L]);
    }
    if(A[center] < A[L]){
        swap(A[L],A[center]);
    }
    //手动设置主元在最后一个元素
    swap(A[center],A[R-1]);
    return A[R-1];
}

void quickSort(int left,int right)
{
    if(left = right){
        return;
    }
    int pivot = getPivot(left,right);
    int i = left;
    int j = right-1;
    while(true){
        while(A[++i] < pivot);
        while(A[--j] > pivot);
        if(i<j){
            swap(A[i],A[j]);
        }else{
            break;
        }
    }
    swap(A[i],A[right-1]);
    quickSort(left,i-1);
    quickSort(i+1,right);
}

void bukkitSort(int n)
{
    int count[1000];
    for(int i=0;i<1000;i++){
        count[i] = 0;
    }
    for(int i=0;i<n;i++){
        count[A[i]]++;
    }
    for(int i=0;i<n;i++){
        if(count[i] != 0){
            for(int j=0;j<count[i];j++)
                cout<<i<<" ";
        }
    }
}

int main()
{
    random();
    outPut();
//    bubbleSort(NUM_SIZE);
//    outPut();
//    insertSort(A,NUM_SIZE);
//    outPut();
//    shellSort(NUM_SIZE);
//    outPut();
//    heapSort(NUM_SIZE);
//    outPut();
//    mergeSortCircle(A,NUM_SIZE);
//    outPut();
//    quickSort(0,NUM_SIZE-1);
//    outPut();
//    bukkitSort(NUM_SIZE);
    return 0;
}

``