【算法修炼之道】——希尔排序

希尔排序(Shell Sort)

什么是希尔排序???——》是为了元素排序而产生的,但是它用的方式和其他排序方式是不一样的;

                                        ——》希尔排序实质上是一种分组插入方法;

 

那它的基本思路???——》

  1. 先选取一个小于n的整数d(称为增量),然后把排序表中的n个记录分为d个子表,从下标为0的记录开始,间隔为d的记录组成一个子表,
  2. 在各个的子表内进行直接插入排序;

 

基本思路代码的实现:

/*
 * 对希尔排序中的单个组进行排序
 *
 * 参数说明:
 *     a -- 待排序的数组
 *     n -- 数组总的长度
 *     i -- 组的起始位置
 *     gap -- 组的步长
 *
 *  组是"从i开始,将相隔gap长度的数都取出"所组成的!
 */
void group_sort(int a[], int n, int i,int gap)
{
    int j;

    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;
        }
    }
}

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

    // gap为步长,每次减为原来的一半。
    for (gap = n / 2; gap > 0; gap /= 2)
    {
        // 共gap个组,对每一组都执行直接插入排序
        for (i = 0 ;i < gap; i++)
            group_sort(a, n, i, gap);
    }
}

 

【例子】数列{80,30,60,40,20,10,50,70},演示它的希尔排序过程。

第一趟:(gap=4)

第二趟:(gap=2)

 

第三趟:(gap=1)

 

上面题目的代码实现:

/**
 * 希尔排序:Java
 *
 * @author skywang
 * @date 2014/03/11
 */

public class ShellSort {

    /**
     * 希尔排序
     *
     * 参数说明:
     *     a -- 待排序的数组
     *     n -- 数组的长度
     */
    public static void shellSort1(int[] a, int n) {

        // gap为步长,每次减为原来的一半。
        for (int gap = n / 2; gap > 0; gap /= 2) {

            // 共gap个组,对每一组都执行直接插入排序
            for (int i = 0 ;i < gap; i++) {

                for (int 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;
                    }
                }
            }
        }
    }

    /**
     * 对希尔排序中的单个组进行排序
     *
     * 参数说明:
     *     a -- 待排序的数组
     *     n -- 数组总的长度
     *     i -- 组的起始位置
     *     gap -- 组的步长
     *
     *  组是"从i开始,将相隔gap长度的数都取出"所组成的!
     */
    public static void groupSort(int[] a, int n, int i,int gap) {

        for (int 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;
            }
        }
    }

    /**
     * 希尔排序
     *
     * 参数说明:
     *     a -- 待排序的数组
     *     n -- 数组的长度
     */
    public static void shellSort2(int[] a, int n) {
        // gap为步长,每次减为原来的一半。
        for (int gap = n / 2; gap > 0; gap /= 2) {
            // 共gap个组,对每一组都执行直接插入排序
            for (int i = 0 ;i < gap; i++)
                groupSort(a, n, i, gap);
        }
    }

    public static void main(String[] args) {
        int i;
        int a[] = {80,30,60,40,20,10,50,70};

        System.out.printf("before sort:");
        for (i=0; i<a.length; i++)
            System.out.printf("%d ", a[i]);
        System.out.printf("\n");

        shellSort1(a, a.length);
        //shellSort2(a, a.length);

        System.out.printf("after  sort:");
        for (i=0; i<a.length; i++)
            System.out.printf("%d ", a[i]);
        System.out.printf("\n");
    }
}

 

既然知道了这种算法的思路,也知道了这种算法该如何实现;那么也就剩下对这种算法性能分析啦!!!

1、希尔排序的空间复杂度???——》由于希尔排序中用到了直接插入排序,而直接插入排序的空间复杂度为O(1);所以希尔排序的空间复杂度为O(1);

2、希尔排序的时间复杂度难分析了???——》关键字的比较次数与记录的移动次数依赖于增量序列的选取;

但是在特定的情况下就可以准确估算出关键字的比较次数和记录的移动次数;

注意:增量序列中应没有除了1之外的公因子,并且最后一个增量值必须为1;

3、该算法是不稳定的;

原文链接:加载失败,请重新获取