排序方法总结

插入排序

基本操作是：将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表

#include <iostream>
#include<stdio.h>
using namespace std;
#define maxn 105
int a[maxn];
void Swap( int *a, int *b )
{
    int t = *a;
    *a = *b;
    *b = t;
}
void InsertSort(int a[],int n){
    for(int i=1;i<n;i++){    //目前已经将a[0…i-1]排好序，此趟将a[i]放到a[0…i-1]的正确位置。
        for(int j=0;j<=i-1;j++){   //在a[0…i-1]中寻找a[i]的正确位置
            if(a[i]<a[j]){
                Swap(&a[i],&a[j]);
            }
        }
    }
}
int main()
{
    int n;
    while(scanf("%d",&n)==1){
        for(int i=0;i<n;i++){
            scanf("%d",&a[i]);
        }
        InsertSort(a,n);
        for(int i=0;i<n;i++){
            printf("%d ",a[i]);
        }
    }
    return 0;
}

快速排序

#include <iostream>
#include<stdio.h>
#define maxn 105
using namespace std;
typedef int ElementType;
ElementType a[maxn];
int Partition(ElementType low,ElementType high){
    int pivotkey=a[low];
    while(low<high){
        while(low<high&&pivotkey<=a[high]){
            high--;
        }
        a[low]=a[high];
        while(low<high&&pivotkey>=a[low]){
            low++;
        }
        a[high]=a[low];
    }
    a[low]=pivotkey;
    return low;
}
void _QuickSort(ElementType low,ElementType high){
    ///确定枢纽的位置
    if(low<high){
        int med=Partition(low,high);
        _QuickSort(low,med-1);
        _QuickSort(med+1,high);
    }
}
void QuickSort(ElementType a[],ElementType n){
    _QuickSort(0,n-1);
}
int main(){
    int n;
    while(scanf("%d",&n)==1){
        for(int i=0; i<n; i++){
            scanf("%d",&a[i]);
        }
        QuickSort(a,n);
        for(int i=0; i<n; i++){
            printf("%d ",a[i]);
        }
    }
    return 0;
}

堆排序

最小堆的性质：
1）儿子的值一定不小于（>=）父亲的值
2）树的节点是按从上到下、从左到右的顺序紧凑排列的

将数据存储在堆上，排序时按照如下操作：

• 建立最大堆（从最后一个节点的父节点开始调整每个元素的位置，将儿子中的较大值与之交换，依次往下过滤，直到叶子节点）
• 循环执行以下步骤，直至所有元素出堆
  • 每次对顶元素（即最大元素）与堆中最后一个元素交换
  • 剔除最大元素后调整为最大堆

#include <iostream>
#include<stdio.h>
using namespace std;
#define maxn 105
typedef int ElementType;
int a[maxn];
/**
1）建立最大堆（从最后一个节点的父节点开始调整）
2）循环执行以下步骤，直至所有元素出堆
    每次对顶元素（即最大元素）与堆中最后一个元素交换
    剔除最大元素后调整为最大堆
*/

void Swap( int *a, int *b )
{
    int t = *a;
    *a = *b;
    *b = t;
}

///将N个元素的数组中以a[p]为根的子堆调整为最大堆
void PerDown(ElementType a[],int p,int n){
    int parent,child;
    ElementType x=a[p];///取出根节点存放的值
    for(parent=p;(parent*2+1)<n;parent=child){
        child=parent*2+1;///左孩子
        if((child!=n-1)&&(a[child]<a[child+1])){
            child++;
        }
        if(x>=a[child])break;
        else
            a[parent]=a[child];
    }
    a[parent]=x;
}
void HeapSort(int a[],int n){
    ///将输入序列调整成最大堆，从最后一个元素的父节点（n/2-1）开始调整
    for(int i=n/2-1;i>=0;i--){
       PerDown(a,i,n);
    }

    for(int i=n-1;i>0;i--){
        Swap(&a[0],&a[i]);
        PerDown(a,0,i);
    }
}
int main()
{
    int n;
    while(scanf("%d",&n)==1){
        for(int i=0;i<n;i++){
            scanf("%d",&a[i]);
        }
        HeapSort(a,n);
        for(int i=0;i<n;i++){
            printf("%d ",a[i]);
        }
    }
    return 0;
}

归并排序

// 归并排序-递归
class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        return mSort(nums, 0, n-1);
    }
    
    vector<int>mSort(vector<int>&nums, int l, int r){
        if(l>=r) return {nums[l]};
        int mid = l+(r-l)/2;
        vector<int>lnum = mSort(nums, l, mid);
        vector<int>rnum = mSort(nums, mid+1, r);
        vector<int>ans;
        int i=0, j=0;
        while(i<=mid-l&&j<=r-mid-1){
            if(lnum[i]<rnum[j])ans.push_back(lnum[i++]);
            else ans.push_back(rnum[j++]);
        }
        while(i<=mid-l) ans.push_back(lnum[i++]);
        while(j<=r-mid-1) ans.push_back(rnum[j++]);
        return ans;
    }
};