• 数据--第28课


    第28课 - 进阶星移

    1. 希尔排列

    将待排序列划分为若干个组,在每一个组内进行插入排序,一整个序列基本有序,后再对整个序列进行插入排列。

    例如:将n个数据元素分成d个子序。

    { R[1],R[1+d],R[1+2d],…,R[1+kd] }。

    { R[2],R[2+d],R[2+2d],…,R[2+kd] }。

    ...

    { R[d],R[2d],R[3d],…,R[kd],R[(k+1)d] }。

    其中,d 称为增量,它的值在排序过程中从大到小逐渐缩小,直至最后一趟排序减为1。

    程序:

    #include <stdio.h>

    void println(int array[], int len)

    {

        int i = 0;

       

        for(i=0; i<len; i++)

        {

            printf("%d ", array[i]);

        }

       

        printf(" ");

    }

    void swap(int array[], int i, int j)

    {

        int temp = array[i];

       

        array[i] = array[j];

       

        array[j] = temp;

    }

    void ShellSort(int array[], int len) // O(n*n)

    {

        int i = 0;

        int j = 0;

        int k = -1;

        int temp = -1;

        int gap = len;

       

        do

        {

            gap = gap / 3 + 1;

       

            for(i=gap; i<len; i+=gap)

            {

                k = i;

                temp = array[k];

               

                for(j=i-gap; (j>=0) && (array[j]>temp); j-=gap)

                {

                    array[j+gap] = array[j];

                    k = j;

                }

           

                array[k] = temp;

            }

           

        }while( gap > 1 );

       

    }

    int main()

    {

        int array[] = {21, 25, 49, 25, 16, 8};

        int len = sizeof(array) / sizeof(*array);

       

        println(array, len);

       

        ShellSort(array, len);

       

        println(array, len);

       

        return 0;

    }

    2. 快速排序

    (1)任取待排序序列中的某个数据元素(例如:第一个元素)作为基准,按照该元素的关键字大小整个序列划分为左右两个子序列:

    l  左侧子序列中所有元素都小于或等于基准元素。

    l  右侧子序列中所有元素都大于基准元素。

    l  基准元素排在这两个子序列中间。

    (2)分别对这两个子序列重复实施上述方法,直到所有的对象都排在相应的位置上为止。

    首先对无序的记录序列进行“一次划分”,之后分别对分割所得两个子序列“递归”进行快速排序。

    例题:

    #include <stdio.h>

    void println(int array[], int len)

    {

        int i = 0;

       

        for(i=0; i<len; i++)

        {

            printf("%d ", array[i]);

        }

       

        printf(" ");

    }

    void swap(int array[], int i, int j)

    {

        int temp = array[i];

       

        array[i] = array[j];

       

        array[j] = temp;

    }

    int partition(int array[], int low, int high)

    {

        int pv = array[low];

       

        while( low < high )

        {

            while( (low < high) && (array[high] >= pv) )

            {

                high--;

            }

           

            swap(array, low, high);

           

            while( (low < high) && (array[low] <= pv) )

            {

                low++;

            }

           

            swap(array, low, high);

        }

       

        return low;

    }

    void QSort(int array[], int low, int high)

    {

        if( low < high )

        {

            int pivot = partition(array, low, high);

           

            QSort(array, low, pivot-1);

            QSort(array, pivot+1, high);

        }

    }

    void QuickSort(int array[], int len) // O(n*logn)

    {

        QSort(array, 0, len-1);

    }

    int main()

    {

        int array[] = {21, 25, 49, 25, 16, 8};

        int len = sizeof(array) / sizeof(*array);

       

        println(array, len);

       

        QuickSort(array, len);

       

        println(array, len);

       

        return 0;

    }

    上面的两种排列方式,虽然都很快,但是还是不稳定的,为了运算的稳定性,我们下面介绍归并排序。

    3. 归并排序

    (1)      将两个或两个以上的有序序列合并成一个新的有序数列:

    (2)      有序序列V[1] …V[m]和V[m+1] …V[n],变成V[1] …V[n],这种归并方法称为2路归并。

    (3)      将3个有序序列归并为一个新的有序列归并为一个新的有序列,称3路归并。

    检测两个有序序列A和和B,C为归并后的新的有序序列:

    当i和j都在两个序列内变化时,根据关键码的大小将较小的数据元素排放到新序列k所指位置中。

    当i与j中有一个已经超出序列时,将另一个序列中的剩余部分照抄到新序列中。

    例子:

    #include <stdio.h>

    #include <malloc.h>

    void println(int array[], int len)

    {

        int i = 0;

       

        for(i=0; i<len; i++)

        {

            printf("%d ", array[i]);

        }

       

        printf(" ");

    }

    void swap(int array[], int i, int j)

    {

        int temp = array[i];

       

        array[i] = array[j];

       

        array[j] = temp;

    }

    void Merge(int src[], int des[], int low, int mid, int high)

    {

        int i = low;

        int j = mid + 1;

        int k = low;

       

        while( (i <= mid) && (j <= high) )

        {

            if( src[i] < src[j] )

            {

                des[k++] = src[i++];

            }

            else

            {

                des[k++] = src[j++];

            }

        }

       

        while( i <= mid )

        {

            des[k++] = src[i++];

        }

    //这里的程序等价于

    //des[k] = src[i];

    //k++;   i++;

        while( j <= high )

        {

            des[k++] = src[j++];

        }

    }

    void MSort(int src[], int des[], int low, int high, int max)

    {

        if( low == high )

        {

            des[low] = src[low];

        }

        else

        {

            int mid = (low + high) / 2;

            int* space = (int*)malloc(sizeof(int) * max);

           

            if( space != NULL )

            {

                MSort(src, space, low, mid, max);

                MSort(src, space, mid+1, high, max);

                Merge(space, des, low, mid, high);

            }

           

            free(space);

        }

    }

    void MergeSort(int array[], int len) // O(n*logn)

    {

        MSort(array, array, 0, len-1, len);

    }

    int main()

    {

        int array[] = {21, 25, 49, 25, 16, 8};

        int len = sizeof(array) / sizeof(*array);

       

        println(array, len);

       

        MergeSort(array, len);

       

        println(array, len);

       

        return 0;

    }

    小结:

    (1)      希尔排序,快速排序和归并排序将排序算法的时间复杂度提高到了O(n*logn)。

    (2)      希尔排序和快速排序的排序结果是不稳定的。

    (3)      归并排序的排序结果是稳定的。

  • 相关阅读:
    CCNP-MPLS-标签交换
    Mac地址表、STP与RSTP原理
    mysql 初始数据库简单操作
    异步回调,事件,线程池与协程
    bug问题
    GIL 线程池
    异常处理
    奇怪的东西
    绑定方法
    初体验
  • 原文地址:https://www.cnblogs.com/free-1122/p/11336013.html
Copyright © 2020-2023  润新知