排序算法实现汇总

插入排序
1、直接插入排序

void InsertSort(vector<int>&arr){
    int n=arr.size();
    int tmp;  //哨兵
    for(int i=1;i<n;i++){
        if(arr[i]<arr[i-1]){  //arr[i]比前面小时插入；
            tmp=arr[i];
            int j;
            for(j=i-1;tmp<arr[j];j--){  //移动；
                arr[j+1]=arr[j];
            }
            arr[j+1]=tmp;  
        }
    }
    for(int i=0;i<n;i++){
        cout<<arr[i]<<" ";
    }
}

2、折半插入排序

void InsertSort(vector<int>&arr){
    int n=arr.size();
    int tmp;  //哨兵
    int l,r,mid;
    for(int i=1;i<n;i++){
        if(arr[i]<arr[i-1]){  //arr[i]比前面小时插入；
            tmp=arr[i];
            l=0;r=i-1;
            while(l<=r){ //r最后保存的会是比tmp小一位的值，当r的值小于tmp时，r的位置保持不变，由l在不断右移；
                mid=(l+r)/2;
                if(arr[mid]>tmp) r=mid-1;
                else l=mid+1;  //arr[mid]==tmp的情况被抛弃，只定位到比tmp小一位的数r；
            } 
            int j;
            for(j=i-1;j>=r+1;j--){  //移动；
                arr[j+1]=arr[j];
            }
            arr[j+1]=tmp;  
        }
    }
    for(int i=0;i<n;i++){
        cout<<arr[i]<<" ";
    }

3、希尔排序

  void ShellSort(vector<int>&arr){
    int length=arr.size();
    for(int i=length/2;i>=1;i/=2){  //步长从2增加到n
        for(int j=i;j<length;j++){ //从第二块区间开始，对j,j-i,j-2i...的区间进行插入插入排序
            if(arr[j]<arr[j-i]){  //插入排序
                int tmp=arr[j];
                int k;
                for(k=j-i;arr[k]>arr[j]&&k>=0;k-=i){
                    arr[k+i]=arr[k];
                }
                arr[k+i]=tmp;
            }
        }
    }
    for(int i=0;i<length;i++){
        cout<<arr[i]<<" ";
    }
}

交换排序
1、冒泡排序

void BubbleSort(vector<int>&arr){
    int length=arr.size();
    int flag=false;
    for(int i=0;i<length;i++){
        flag=true;
        for(int j=length-1;j>i;j--){
            if(arr[j]<arr[j-1]){
                swap(arr[j],arr[j-1]);
                flag=false;
            }
        }
        if(flag) break;
    }
    
    for(int i=0;i<length;i++){
        cout<<arr[i]<<" ";
    }
}

2、快速排序

int Partition(vector<int>&arr,int l,int r){
    int target=arr[l];
    while(l<r){
        while(l<r&&arr[r]>target) r--;
        arr[l]=arr[r];
        while(l<r&&arr[l]<=target) l++;
        arr[r]=arr[l];
    }
    arr[l]=target;
    return l;
}

void QuickSort(vector<int>&arr,int l,int r){
    if(l<r){
        int pivotpos=Partition(arr,l,r);  //先序遍历，先把表分为两边，再分别进行递归排序；
        QuickSort(arr,l,pivotpos-1);
        QuickSort(arr,pivotpos+1,r);
    }
}

堆排序

void HeapAdjust(vector<int>&arr,int k,int length){
    for(int i=2*k;i<=length;i=k*2){
        if(i+1<=length&&arr[i]<arr[i+1]){
            i++;
        }
        if(arr[i]<=arr[k]) break;
        else swap(arr[i],arr[k]),k=i;
    }
}
void BuildMaxHeap(vector<int>&arr){
    int length=arr.size()-1;
    for(int i=length/2;i>0;i--){
        HeapAdjust(arr,i,length);
    }
}

void HeapSort(vector<int>&arr){  
    BuildMaxHeap(arr);   //对数组建立堆
    for(int i=arr.size()-1;i>0;i--){  
        swap(arr[i],arr[1]);
        HeapAdjust(arr,1,i-1);
    }
}