王道2025数据结构代码总结：第八章 排序

8.2.1

直接插入排序

void InsertSort(ElemType A[],int n){
    int i,j;
    for(i=2;i<=n;i++)
        if(A[i]<A[i-1]){
            A[0]=A[i];//赋值为哨兵，A[0]存放A[i],A[0]不存放元素
            for(j=i-1;A[0]<A[j];j--)
                A[j+1]=A[j];
            A[j+1]=A[0];
        }
}

8.2.2

折半插入排序

void InsertSort(ElemType A[],int n){
    int i,j,low,high,mid;
    for(i=2;i<=n;i++){
        A[0]=A[i];
        low=1;
        high=i-1;
        while(low<=high){
            mid=(low+high)/2;
            if(A[mid]>A[0])
                high=mid-1;
            else
                low=mid+1;
        }
        for(j=i-1;j>=high+1;--j)
            A[j+1]=A[j];
        A[high+1]=A[0];
    }
}

8.2.3

希尔排序

void ShellSort(ElemType A[],int n){
//A[0]只是暂存单元，不是哨兵，当j<=0时，插入位置已到
    int dk,i,j;
    for(dk=n/2;dk>=1;dk=dk/2)
        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];
            }
}

8.3.1

冒泡排序

void BubbleSort(ElemType A[],int n){
    for(int i+0;i<n-1;i++){
        bool flag=false;
        for(int j=n-1;j>i;j--)
            if(A[j-1]>A[j]){
                swap(A[j-1],A[j]);
                flag=true;
            }
        if(flag==false)
            return;
    }
}

8.3.2

快速排序

void QuickSort(ElemType A[],int low,int ligh){
    if(low<high){
    //Partition()就是划分操作，将表A[low···high]划分为满足上述条件的两个子表
        int pivotpos=Partition(A,low,high);
        QuickSort(A,low,pivotpos-1);//左子表
        QuickSort(A,pivotpos+1,high);//右子表
    }
}

快速排序中的划分操作

int Partition(ElemType A[],int low,int high){
    ElemType pivot=A[low];
    while(low<high){
        while(low<high&&A[high]>=pivot)
            --high;
        A[low]=A[high];
        while(low<high&&A[low]<=povit)
            ++low;
        A[high]=A[low];
    }
    A[low]=pivot;
    return low;
}

8.4.1

简单选择排序

void SelectSort(ElemType A[],int n){
    for(int i=0;i<n-1;i++){
        int min=i;
        for(int j=i+1;j<n;j++)
            if(A[j]<A[min])
                min=j;
        if(min!=i)
            swap(A[i],A[min]);
    }
}

8.4.2

建立大根堆

void BuildMaxHeap(ElemType A[],int len){
    for(int i=len/2;i>0;i--){
        HeadAdjust(A,i,len);
    }
    void HeadAdjust(ElemType a[],int k,int len){
    //函数HeadAdjust对以元素k为根的子树进行调整
        A[0]=A[k];
        for(int i=2*k;i<=len;i*=2){
            if(i<len&&A[i]<A[i+1])
                i++;
            if(A[0]>A[i])
                break;
            else{
                A[k]=A[i];
                k=i;
            }
        }
        A[k]=A[0];
}

堆排序

void HeapSort(ElemType A[],int len){
    BuildMaxHeap(A,len);
    for(int i=len;i>1;i--){
        Swap(A[i],A[1]);
        HeadAdjust(A,1,i-1);
    }
}

8.5.1

二路归并排序

ElemType *B=(ElemType *)malloc((n+1)*sizeof(ElemType));
void Merge(ElemType A[],int low,int mid,int high){
//表的两段A[low...mid]和A[mid+1...high]各自有序，将它们合并成一个有序表
    int i,j,k;
    for(k=low;k<=high;k++)
        B[k]=A[k];
    for(i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){
        if(B[i]<=B[j])
            A[k]=B[j++];
    }
    while(i<=mid)
        A[k++]=B[i++];
    while(j<=high)
        A[k++]=B[j++];
}

递归形式的二路归并排序

void MergeSort(ElemType A[],int low,int high){
    if(low<high){
        int mid=(low+high)/2;
        MergeSort(A,low,mid);
        MergeSort(A,mid+1,high);
        Merge(A,low,mid,high);
    }
}