排序算法总结

 

一、堆排序

算法模板  模板题目

#include <bits/stdc++.h>
using namespace std;
int a[100010];
int n,len;
void Update(int root)
{
    int left=root*2+1;  
    int right=root*2+2; 
    if(right>len)
    {
        if(left>len)
            return;
        if(a[left]>a[root])
            swap(a[left],a[root]);
        return;
    }
    while(true)
    {
        if(a[root]>=a[left]&&a[root]>=a[right])
            break;
        if(a[left]>a[right]){
            if(a[left]>a[root]){
                swap(a[left],a[root]);
                root=left;
            }
        }
        else{
            if(a[right]>a[root]){
                swap(a[right],a[root]);
                root=right;
            }
        }
        left=root*2+1;
        right=root*2+2;
        if(left>len&&right>len)
            break;
        if(right>len){
            if(a[left]>a[root])
                swap(a[root],a[left]);
            break;
        }
    }
    return;
}
/**
*可以输出堆查看
void show()
{
    int one=1,sum=1;
    cout<<"========================="<<endl;
    for(int i=1;i<=n;i++){
        cout<<a[i-1]<<"  ";
        if(i==sum){
            cout<<endl;
            one*=2;
            sum+=one;
        }
    }
    cout<<endl<<len<<"======================="<<endl;
}
*/
void dui_paixu()
{
    int pos=n-1;
    pos=(pos-1)/2; //最后一个非叶节点的位置
    len=n-1;
    for(int i=pos; i>=0; i--){ //从最后一个非叶节点开始，调整为大顶堆
        Update(i);
    }
    while(len>0){
        swap(a[0],a[len]);
        len--;
        Update(0);
    }
    return;
}

int main()
{
    scanf("%d",&n);
    for(int i=0; i<n; i++){
        scanf("%d",&a[i]);
    }
    dui_paixu();
    for(int i=0;i<n;i++)
        printf("%d%c",a[i],i!=n-1?' ':'\n');
    return 0;
}

前导知识：

大顶堆： 将堆看作一个二叉树，即对于每个非叶结点的值都大于其左右结点的值。

存储方式： 因为堆可以看作一个完全二叉树，所以用一维数组就可以存储，假设一共有 n 个结点，根节点即为数组的 0 号位置，最后一个结点的序号为 n-1 

完全二叉树的最后一个非叶节点的序号为：  (n-2)/2  

堆排序的思想： 假如我们要对 a 数组进行升序排序，排序函数主要分为两部分；

首先 将 a 数组构建成一个大顶堆（时间复杂度是低于 O(nlogn) 的，具体是多少没有计算 ），构建大顶堆的方法：

从最后一个非叶节点开始到根节点，逐一判断是否满足该节点的值大于其左右子节点，不满足的话与左右节点中值较大的节点交换，如果当前节点的堆结构变了，还要考虑是否影响到了其子节点的大顶堆结构，所以这是一个循环判断，具体看代码实现

构建完大顶堆后，堆顶（或者说树根）的值是最大值，将树根的值与最后一个节点交换，就将最大值换到了最后，然后舍弃后面已经排好序的值（这里的舍弃意思是以后再更新大顶堆的结构时，不用考虑这些节点，因为这些节点已经排好序了），这时堆顶一定不是最大值了，所以对堆进行更新，将最大值（舍弃排好序的那些值的最大值）更新到堆顶，再交换到最后一个节点（这里的最后一个节点也是舍弃排好序的那些节点的最后一个节点），直到排好序。

 

 

二、快速排序

public class QuickSort {
    
    public static void main(String[] args) {
        int[] arr = {49,38,65,97,23,22,76,1,5,8,2,0,-1,22};
        quickSort(arr,0,arr.length-1);
        for(int i: arr){
            System.out.print(i + " ");
        }
    }

    public static void quickSort(int[] arr, int left, int right){
        if(left < right){

            int index = getIndex(arr, left, right);

            quickSort(arr, left, index-1);
            quickSort(arr, index+1, right);

        }
    }

    public static int getIndex(int[] arr, int left, int right){

        int tmp = arr[left];
        while(left < right){

            while(left<right && arr[right]>=tmp){
                right--;
            }
            arr[left] = arr[right];

            while(left<right && arr[left]<=tmp){
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = tmp;
        return left;
    }
}

三、归并排序

public class MergeSort {

    public static void main(String[] args) {
        int[] arr = {49,38,65,97,23,22,76,1,5,8,2,0,-1,22};
        mergeSort(arr,0,arr.length-1);
        for(int i: arr){
            System.out.print(i + " ");
        }
    }

    public static void mergeSort(int[] arr, int left, int right){

        if(left >= right)
            return;
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid+1, right);
        mergeArr(arr, left, right, mid);
    }

    public static void mergeArr(int[] arr, int left, int right, int mid){

        Queue<Integer> queue = new LinkedList<>();
        int i = left;
        int j = mid + 1;
        while(i<=mid || j<=right){
            if(i > mid){
                queue.add(arr[j++]);
            } else if(j > right){
                queue.add(arr[i++]);
            } else if(arr[i] <= arr[j]){
                queue.add(arr[i++]);
            } else if(arr[j] <= arr[i]){
                queue.add(arr[j++]);
            }
        }
        i = left;
        while(!queue.isEmpty()){
            arr[i++] = queue.poll();
        }
    }
}