排序算法

1.冒泡排序

• 实现冒泡排序，基于一个整数的数组进行排序
• 升序排序
• 时间复杂度O(N^2)
• 空间复杂度O(1)
• 稳定性：稳定

代码如下：

void Swap(int *a,int *b) 
{
        int temp = *a; 
        *a = *b; 
        *b = temp;
        return;
}
void BubbleSort(int array[],int64_t size)
{
        if(size <= 1){ 
                return;
        }   
        int64_t Bound=0;
        //采用每次循坏找到最小数字的方式进行冒泡
        //[0,Bound]是当前有序的区间
        //[bound,size]是待排序的区间
        for(;Bound<size;Bound++){
        //每循坏一次，有序区间就加一个元素
                int64_t cur=size-1;
                for(;cur>Bound;cur--){
                //此次循坏就是找最小的数值
                        if(array[cur]<array[cur-1]){
                                Swap(&array[cur],&array[cur-1]);
                        }   
                }   
        }
        return;
}

2.选择排序

• 升序排序
• 时间复杂度：O(N^2)
• 空间复杂度：O(1)
• 稳定性：不稳定

基本思路：

• 将[0,bound]作为有序区间，每循坏一次，有序区间的个数会增加1
• 内层循坏将bound作为基准值，每遍历一次，就会找到一个最小值

代码如下：

void SelectSort(int array[],int64_t size)
{
        if(size<=1){
                return;
        }
        int64_t bound=0;
        //[0,bound]是有序区间
        for(;bound<size;bound++){
                int64_t current=bound;
        //选定array[bound]为擂台
        //每次循坏找出当前区间的最小值
                for(;current<size;current++){
                        if(array[current]<array[bound]){
                                Swap(&array[current],&array[bound]);
                        }   
                }   
        }   
}

3.插入排序

• 时间复杂度：O(N^2)
• 空间复杂度：O(1)
• 稳定性：不稳定

算法思想：

假定我们的牌只有1张时，认为该牌组的牌序是有序的。(5,1,4,2)

       那么，我们就可以将我们的一组牌分为左右两组了，起始情况下：

          1)左边牌组:5

          2)右边牌组:1,4,2

       好了，左边牌序根据我们的假设，它已经是有序的。

第一次插入，

       我们从右边牌组中只取第一张牌(1)插入到左边牌组的合适位置。   

         1)左边牌组:1,5

         2)右边牌组:4,2

第二次插入，
       我们从右边牌组中依然只取第一张牌(4)插入到左边牌组的合适位置。

         1)左边牌组:1,4,5

         2)右边牌组:2

第三次插入，

       我们从右边牌组中只取第一张牌(2)插入到左边牌组的合适位置。   

         1)左边牌组:1,2,4,5

         2)右边牌组:

代码如下：

void InsertSort(int array[],int64_t size)
{
        if(size<=1){
                return;
        }
        int64_t bound=1;
        //[0,bound]是有序区间
        //[bound,size]是待排序区间
        //把bound位置的元素插入到前面有序区间的合适位置
        for(;bound<size;bound++){
                int64_t bound_value=array[bound];
                int i=bound;
                for(;i>0;i--){
                        if(array[i-1]>bound_value){
                        //进行搬运
                                array[i]=array[i-1];
                        }else{
                        //已经找到合适的位置
                                break;
                        }   
                }   
                array[i]=bound_value;
        //上面这行代码代表的含义：
        //1.当前数组中的这个元素已经小于bound_value
        //  需要把bound_value放到这个元素的后面，也就是放到i的位置上
        //2.处理循坏结束的情况，如果bound_value刚好是
        //当前有序顺序表中最小的元素，此时达到i==0的时候，循坏就退出了
        //这时需要把bound_value放到下标为0的位置上
        }
}