C++选择冒泡插入希尔排序

排序

1.插入排序

​ 插入排序思路与打扑克牌的思路类似，从第二项开始，比较所得的与现有序列元素的大小，插入应有的有序序列。实现时需要将比插入值大的值都往后移位，后插入，保证元素不会被覆盖消失。

​ 插入排序的时间复杂度为O(n*n)，且排序算法稳定。

​

void insertionSort(int *a,int n)
{
    int v,j;
    for(int i =1;i<n;i++)
    {
        v = a[i];
        j = i-1;
        while(j>=0&&a[j]>v)
        {
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = v;
    }
}

2.冒泡排序

​ 冒泡排序从一端开始，该元素与整个待排序序列的大小，若满足条件，则交换。遍历整个数组后，将该位置从待排序序列排除。

​ 冒泡排序的时间复杂度为O(n*n)，且排序算法稳定。

int bubbleSort(int *a,int n)
{
    int times = 0;
    bool flag = 1;
    for(int i = 0;flag;i++){
        flag = 0;  //flag 用于优化算法，若待排序序列为顺序列，直接返回
        for(int j = n-1;j>=i+1;i--){
            if(a[j]<a[j-1]){
               	swap(a[j],a[j-1]);
                flag = 1;
                times++;
            }
        }
    }
    return times; //返回交换次数，即为逆序数
}

3.选择排序

​ 选择排序与冒泡排序思路相反，冒泡是从局部来减少逆序元素，而选择是放眼大局来逐个选择最值。但是两个都是通过外层循环顺次求出最值。

​ 选择排序时间复杂度为O(n*n)，排序算法不稳定；

int SelectionSort(int *a,int n)
{
    int times = 0;
    for(int i=0;i<n-1;i++){
        int minj = i;
        for(int j = i+1;j<n;j++){
            if(a[j]<a[minj]){
                minj = j;
            }
        }
        if(minj! = i){
            swap(a[minj],a[j]);
            times++;
        }
    }
}

4.希尔排序

​ 希尔排序是插入排序的一种，是插入排序的改进，希尔排序又称缩小增量排序。

​ 希尔排序实质上是一种分组插入方法。它的基本思想是：对于n个待排序的数列，取一个小于n的整数gap(gap被称为步长)将待排序元素分成若干个组子序列，所有距离为gap的倍数的记录放在同一个组中；然后，对各组内的元素进行直接插入排序。 这一趟排序完成之后，每一个组的元素都是有序的。然后减小gap的值，并重复执行上述的分组和排序。重复这样的操作，当gap=1时，整个数列就是有序的。

/*
 * 希尔排序
 *
 * 参数说明：
 *     a -- 待排序的数组
 *     n -- 数组的长度
 */
void shell_sort1(int a[], int n)
{
    int i,j,gap;

    // gap为步长，每次减为原来的一半。
    for (gap = n / 2; gap > 0; gap /= 2)
    {
        // 共gap个组，对每一组都执行直接插入排序
        for (i = 0 ;i < gap; i++)
        {
            for (j = i + gap; j < n; j += gap) 
            {
                // 如果a[j] < a[j-gap]，则寻找a[j]位置，并将后面数据的位置都后移。
                if (a[j] < a[j - gap])
                {
                    int tmp = a[j];
                    int k = j - gap;
                    while (k >= 0 && a[k] > tmp)
                    {
                        a[k + gap] = a[k];
                        k -= gap;
                    }
                    a[k + gap] = tmp;
                }
            }
        }

    }
}