排序分析

按照排序方法将排序分为五类：

                                               一类：插入类排序：直接插入排序，折半插入排序，希尔排序

                                                二类：交换类排序：快排，冒泡排序

                                                三类：选择类排序：简单选择排序，堆排

                                                四类 ：归并类排序：二路归并排序

                                                 五类：基数类排序

从时间复杂度上来讲

                             平均时间复杂度为O(N^2)

                               冒泡排序，直接插入排序，简单选择排序，折半插入排序

                             平均时间复杂度为O()

                              快排，归并排序，堆排

                             最差时间复杂度除快排为O(N^2)以外 其余都与平均时间复杂度一致

                             空间复杂度上来说 

                             快排为O(l)，归并排序为O(N),基数排序为O(Rd)，其余都是O(1)

稳定性：

                除简单选择排序，快排，希尔排序，堆排是不稳定的，其余都为稳定

 

tips：

       1. 经过一躺排序，能够保证一个关键字在最终位置，这样的排序是交换类的两种（起泡和快速），选择类的两种（简单选择，堆）

       2.排序算法的关键词比较次数与原始序列无关的是--------折半插入和简单选择排序。

       3.排序算法的排序躺数与原始序列相关-----交换类排序。

贴个快排和堆排的代码

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
int t=0;
void InsertSort(int R[],int n){
    int i,j;
    int temp;
    for(int i=0;i<n;++i){
        temp=R[i];
        j=i-1;
        while(j>=0&&temp<R[j]){
            R[j+1]=R[j];
            --j;
            t++;
        }
                R[j+1]=temp;
           /* for(int q=0;q<n;q++){
                cout<<R[q]<<" ";
            }
            cout<<endl;
            */

        }
}
void QuickSort(int R[],int low,int high){
    int temp;
    int i=low,j=high;
    if(low<high){
        temp=R[low];
        while(i<j){
            while(j>i&&R[j]>=temp) --j;
            if(i<j){
                R[i]=R[j];
                ++i;
            }
            while(i<j&&R[i]<temp) ++i;
            if(i<j){
                R[j]=R[i];
                --j;

            }
        }
        R[i]=temp;
        QuickSort(R,low,i-1);
        QuickSort(R,i+1,high);
    }
}
//生成树
void sift(int R[],int low,int high){
    int i=low,j=2*i;
    int temp=R[i];
    while(j<=high){
        if(j<high&&R[j]<R[j+1]){
            ++j;
        }
        if(temp<R[j]){
            R[i]=R[j];
            i=j;
            j=2*i;
        }
        else
            break;
    }
    R[i]=temp;
}
void heapSort(int R[],int n){
    int i;
    int temp;
    for(int i=n/2;i>=0;--i)
        sift(R,i,n);
    for(i=n;i>=0;--i){
        temp=R[0];
        R[0]=R[i];
        R[i]=temp;
        sift(R,0,i-1);
    }

}
int main(){
    int n;
    cin>>n;
    int R[105];
    for(int i=0;i<n;i++){
        cin>>R[i];
    }
    int q;
    cout<<"堆排请输入1"<<endl;
    cout<<"快排输入2"<<endl;
    cin>>q;
    if(q==1){
        heapSort(R,n);
    }
    else if(q==2){
        QuickSort(R,0,n-1);
    }
    //InsertSort(R,n); 直接排序；
    //折半插入 前提是有序的序列，向其中添加新的数字
    //QuickSort 快排 时间复杂度为nlogn 最坏时间复杂度为 n^2, 空间复杂度为 log2(N);
    for(int i=0;i<n;i++){
        cout<<R[i]<<" ";
    }
    return 0;
}