排序(上)

插入排序

每次将一个待排序的记录，按其大小插入到前面已经排好序列的子序列当中，直到全部记录插入完成

直接插入排序
void InsertSort(int A[],int n){
    int i,j,temp;
    for(i=1,i<n,i++){
        if(A[i]<A[i-1]){   //当前处理的元素比前面一个小就交换 ： 49，38   38->49 
            temp =A[i];
            for(j=i-1;j>0&&A[j]>temp;j--){      //检查前面已经排列好的元素
             A[j+1]=A[j];    //所有大于temp的往后移    
            }
            A[j-1]=temp;
        }
    }
}

带哨兵的直接插入排序（把0的位置空出来做成哨兵）
void InsertSort(Int A[],int n){
    int i, j;
    for(int i =2;i<=n;i++){   //注意别忘了等号，依次将A[2]~A[n]插入到前面已经排序的序列中
        if(A[i]<A[i-1])  //后面比前面的小，交换
        {
           A[0]=A[i];
            for(int j =i-1;A[j]>A[0];j--){   //不用判断J>0了，因为当j=0时，A[j]==A[0],已经满足的退出的条件
                A[j+1]=A[j];
            }
            A[j]=A[0];
        }
    }
}

优化——折半插入查找
void InsertSort(Int A[],int n){
    int i, j, low, high;
    for(i=2 ;i<=n;i++){  //遍历A的每一个元素,i从2开始，别忘了等号
        A[0] =A[i];     //哨兵
        low=1;high=i-1;  //折半查找的范围，是动态变化的
        while(low<=high)  //折半查找，找到要插入的位置(递增)
        {
            mid =(low+high)/2;
            if(mid >A[0]){
                high=mid-1;
            }
            else{
                low=mid+1;   //如果mid==A[0]，也要继续在右边找，因为要保证算法的稳定性
            }
        }
        //low>high,将low到i-1的位置都往后移动一个
        for(j=i-1;j>=low;j--){
            A[j+1]=A[j];
        }
        A[low] =A[0];  //插入
    }
}

 
折半插入查找的思想：先用折半查找找到要插入的位置（三种情况，value>mid,value=mid,value<mid,而这三种情况都应该以low>value结束，这样就能保证，从low到i-1的元素要统一后移，而low的位置就是我们要插入的位置，同时也保证了准确性）后移后再插入。

• 空间负责度：O(1) 时间复杂度： 最好O(n) 最坏O（n平方） 平均O(n平方) 稳定

希尔排序（Shell Sort）

一个叫希尔的人发明的排序

void ShellSort(int A[],int n){
    int d,i,j;
    for(d=n/2;d>=1;d=d/2){        //限定每一次的步长
        for(i=d+1;i<=n;i++)      //从间隔d后面算起（d+1），遍历间隔步长d后面的每一个元素
        {
            if(A[i-d]<A[i]){     //如果i-d的值大于i的值,就后移A[i-d]
             A[0]=A[i];          //暂存     
             for(j=i-d;j>0&&A[j]>A[0];j-=d){     //该循环表示将与A[i]间距为d的所有元素都比较一次
                 A[j+d]=A[j];
             }
            A[i+d]=A[0];  //赋值,注意要+d
            }
        }   
    }
}

当d直接等于1时，Shell排序就退化成了直接插入排序

• 空间负责度：O(1) 时间复杂度： 和增量序列有关，目前无法用数学手段证明确切的时间复杂度，比直接插入排序优秀 不稳定

交换排序

冒泡排序

void BubbleSort(int A[],int n){
    for(int i=0;i<n;i++){
        bool flag= false;
        for(int j=n-1;j>i;j--){    //第i躺有i个元素有序所以j>i而不是j>0
            if(A[j]<A[j-1]){   //值相同不交换
                int temp=A[j];
                A[j]=A[j-1];
                A[j-1]=temp;
                flag=true;
            }
            if(!flag){
                return;
            }
        }
    }
}

• 空间复杂度：O(1) 最好情况(有序)：O(n) 最坏情况(有序)：O(n平方) 平均O(n平方)

• 每次交换都需要移动元素3次，可以运用于链表

快速排序

划分子表

high不断左移动，找到比枢轴更小的为止；

low不断右移动，直到找到比枢轴大的为止

void QuickSort(int A[],int low,int high){
    if(low<high)
    int postion =Partition(A,low,high);//返回枢轴所在的位置
    QuickSort(A,low,position-1);//左边
    QuickSort(A，position+1,high);//右边
}
​
//用第一个元素将待排序序列划分成左右两个部分
​
int Partition(int A[],int low,int high){
    int pivot = A[low];
    while(low<high){
        while(low<high&&A[high]>=pivot) --high;   //不要忘了判断low，high
        A[low]=A[high];    
        while(low<high&&A[low]<=pivot) ++low;     //不加low<high，当low==high时会出现空指针异常
        A[high]=A[low];
    }
    //low==high
    A[low]=pivot;
    return low;
}

• 空间复杂度：最好O(logn) 最坏O(n) 最好情况(有序)：O(nlogn) 最坏情况(有序)：O(n平方) 平均O(nlogn) 不稳定