算法--排序（希尔，归并）

最新推荐文章于 2022-12-05 22:07:42 发布
最新推荐文章于 2022-12-05 22:07:42 发布
阅读量484 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangyl_gain/article/details/50537355
版权

希尔排序

插入排序在对几乎已经排好序的数组进行排序时，效率高，可以达到线性排序的效率。但对于大规模乱序数组（特别是逆序数组），插入排序很慢。因为他只会交换相邻的元素，元素只能一点点从数组一端移动到另一端。
希尔排序的思想：

交换不相邻的元素以对数组的局部进行排序，并最终用插入排序将局部有序的数组排序。使数组中任意间隔为h的元素都是有序的。其中h为任意以1结尾的整数序列。

增量序列h：
希尔排序的执行时间依赖于增量序列，好的增量序列的共同特征：
1. 最后一个增量必须为1；
2. 应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况。

排序过程：
这里写图片描述

程序代码：

public class ShellSort<T extends Comparable<T>> implements Sort<T> {
    //核心算法，增量序列 1 4 13 ....（3*h+1）
    public void sort(T[] a) {
        int N = a.length;
        int h = 1;
        while(h < N/3) h = 3*h + 1;
        while(h > 0 ) {
            for(int i=h; i<N; i++) {
                for(int j=i; j>=h && less(a[j], a[j-h]); j -= h) {
                    swap(a, j, j-h);
                }
            }
            h = h/3;
        }

    }

    //比较两个元素大小
    public boolean less(T a,T a2) {
        return a.compareTo(a2)<0;
    }

    //交换两个元素
    public void swap(T[] a,int i,int j) {
        T temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public boolean isSorted(T[] a) {
        int N = a.length;
        for(int i=1; i<N; i++) {
            if(less(a[i],a[i-1]))
                return false;
        }
        return true;
    }

    //测试
    public static void main(String[] args) {
        Integer[] a = {3,8,2,5,9,1,4,6,0,7};
        ShellSort<Integer> ss = new ShellSort<Integer>();
        ss.sort(a);
        System.out.println(ss.isSorted(a));
    }
}

分析：

  1. 希尔排序的运行时间最坏情况达不到平方级别

  2. 希尔排序是不稳定的排序，代码量小，原地排序。

  3. 希尔排序优于插入排序，但没有快速排序快（快速排序最坏情况下除外）。

测试

代码如下:

public class Test {
    public static final int NUM = 10000;

    public static <T> double testSort(T[] data, Sort<T> sort) {
        StopWatch timer = new StopWatch();
        sort.sort(data);
        return timer.elapsedTime();
    }

    public static void main(String[] args) {
        Double[] data1 = new Double[NUM];
        for(int i=0; i < NUM; i++) {
            data1[i] = Math.random();
        }

        Double[] data2 = new Double[NUM];
        for(int i=0; i < NUM; i++) {
            data2[i] = data1[i];
        }

        Double[] data3 = new Double[NUM];
        for(int i=0; i < NUM; i++) {
            data3[i] = data1[i];
        }

        InsertionSort<Double> its = new InsertionSort<Double>();
        SelectionSort<Double> sts = new SelectionSort<Double>();
        ShellSort<Double> sls = new ShellSort<Double>();

        double time1 = Test.testSort(data1,sts);
        double time2 = Test.testSort(data2,its);
        double time3 = Test.testSort(data3,sls);
        System.out.println("SelectionSort---->" + time1);
        System.out.println("InsertionSort---->" + time2);
        System.out.println("ShellSort---->" + time3);
    }
}

class StopWatch {
    public final long start;
    public StopWatch() {
        start = System.currentTimeMillis();
    }

    public double elapsedTime() {
        long now = System.currentTimeMillis();
        return (now-start)/1000.0;
    }
}

结果如下：
这里写图片描述

希尔排序比插入排序和选择排序要快的多，并且数组越大，优势越大。

归并排序

排序思想：

归并排序是基于归并操作实现的，即将两个有序的数组归并成一个更大的有序数组。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

归并排序可分为

  • 自顶向下的归并排序
  • 自底向上的归并排序

自顶向下的归并排序

自顶向下的归并排序过程：
这里写图片描述

代码如下：

/**
 1. 自顶向下的归并排序
 */
public class MergeSort<T extends Comparable<T>> implements Sort<T> {
    private T[] array; //辅助数组


    public void sort(T[] a) {
        array = (T[]) new Comparable[a.length];
        mergeSort(a, 0, a.length - 1);

    }

    //核心算法
    public void mergeSort(T[] a, int down, int up) {
        if (up <= down) return; //结束条件
        int mid = (up - down) / 2 + down;
        mergeSort(a, down, mid); //左半边排序
        mergeSort(a, mid + 1, up); //右半边排序
        merge(a, down, mid, up);
    }

    //一个数组左右半边分别有序，归并
    public void merge(T[] a, int down, int mid, int up) {
        int i = down, j = mid + 1;
        //复制数组中元素
        for (int k = down; k <= up; k++) {
            array[k] = a[k];
        }

        for (int k = down; k <= up; k++) {
            if (i > mid) a[k] = array[j++]; //左半边用尽，取右半边元素
            else if (j > up) a[k] = array[i++];
            else if (less(array[i], array[j])) //左半边元素比右半边小
                a[k] = array[i++];
            else a[k] = array[j++];
        }
    }

    //比较两个元素大小
    public boolean less(T a, T a2) {
        return a.compareTo(a2) < 0;
    }

    public boolean isSorted(T[] a) {
        int N = a.length;
        for (int i = 1; i < N; i++) {
            if (less(a[i], a[i - 1]))
                return false;
        }
        return true;
    }

    //测试
    public static void main(String[] args) {
        Double[] a = new Double[100];
        for (int i = 0; i < 100; i++) {
            a[i] = Math.random();
        }
        MergeSort<Double> ss = new MergeSort<Double>();
        ss.sort(a);
        System.out.println(ss.isSorted(a));
    }
}

分析：

  1. 比较次数0.5*NlogN到NlogN，访问数组最多6NlogN

  2. 时间复杂度O(NlogN)，空间复杂度O(N)

  3. 优点：所需时间短，速度快。 缺点：所需空间和数组大小成正比

自底向上的归并排序

排序思想：

先两两归并（把每个元素当成一个长度为1的数组），在四四归并，然后八八归并，一直下去。每轮归并中最后一次归并的第二个数组可能比第一个小（注意不要越界）。

代码如下：

public class MergeUpSort<T extends Comparable<T>> implements Sort<T> {
    private T[] array; //辅助数组

    public void sort(T[] a) {
        array = (T[]) new Comparable[a.length];
        mergeSort(a);
    }

    //核心算法
    public void mergeSort(T[] a) {
        int N = a.length;
        for (int i = 1; i < N; i = 2 * i) {
            for (int j = 0; j < N - i; j += 2 * i)
                merge(a, j, j + i - 1, Math.min(j + 2 * i - 1, N - 1));
        }
    }

    //一个数组左右半边分别有序，归并
    public void merge(T[] a, int down, int mid, int up) {
        int i = down, j = mid + 1;
        //复制数组中元素
        for (int k = down; k <= up; k++) {
            array[k] = a[k];
        }

        for (int k = down; k <= up; k++) {
            if (i > mid) a[k] = array[j++]; //左半边用尽，取右半边元素
            else if (j > up) a[k] = array[i++];
            else if (less(array[i], array[j])) //左半边元素比右半边小
                a[k] = array[i++];
            else a[k] = array[j++];
        }
    }


    //比较两个元素大小
    public boolean less(T a, T a2) {
        return a.compareTo(a2) < 0;
    }

    public boolean isSorted(T[] a) {
        int N = a.length;
        for (int i = 1; i < N; i++) {
            if (less(a[i], a[i - 1]))
                return false;
        }
        return true;
    }

    //测试
    public static void main(String[] args) {
        Double[] a = new Double[1050];
        for (int i = 0; i < 1050; i++) {
            a[i] = Math.random();
        }
        MergeUpSort<Double> ss = new MergeUpSort<Double>();
        ss.sort(a);
        System.out.println(ss.isSorted(a));
    }
}

改进

对于自顶向下的归并排序：

  1. 归并排序在处理小规模问题时，由于方法的调用过于频繁，会产生过多的额外开销。插入排序在处理小数组上比归并排序更快。在用归并排序处理大规模数据时，，使用插入排序来处理小规模的子数组，一般可使归并排序的运行时间缩短10%-15%
  2. 添加一个判断，如果a[mid]小于a[mid+1],则数组已经有序，不需要进行归并操作。这样可大大减小有序子数组的运行时间。
  3. 通过在递归调用的每个层次交换输入数组和辅助数组的角色，节省元素复制到辅助数组中的时间(空间不行）。即在递归中，数据从输入数组排序到辅助数组和从辅助数组排序到输入数组交替使用。

改进后代码如下：

package com.gain.sort;

/**
 * 改进自顶向下的归并排序
 * 1. 对小规模数组使用插入排序
 * 2. 加入数组是否有序的判断，减少归并次数
 * 3. 通过在递归中交换参数，避免数组复制
 * Created by gain on 2016/1/18.
 */
public class MergeInsSort<T extends Comparable<T>> implements Sort<T> {
    public static final int CUTOFF = 10; //插入排序处理数组长度
    private T[] array;

    public void sort(T[] a) {
        array = a.clone();
        mergeSort(array, a, 0, a.length - 1);

    }

    //核心算法, 对dst进行排序
    public void mergeSort(T[] src, T[] dst, int down, int up) {
        //if (up <= down) return; //结束条件

        //改进,小规模用插入排序
        if (up - down <= CUTOFF) {
            insertionSort(dst, down, up);
            return;
        }
        int mid = (up - down) / 2 + down;
        mergeSort(dst, src, down, mid); //左半边排序，交换输入数组和辅助数组角色
        mergeSort(dst, src, mid + 1, up); //右半边排序，结果：src中有序

        /*if(less(src[mid], src[mid + 1])) {
            for(int i=down; i<=up;i++) {
                dst[i] = src[i];
            }
            return;
        }*/
        //比上面循环更快
        if(less(src[mid], src[mid + 1])) {
            System.arraycopy(src, down, dst, down, up-down+1);
            return;
        }
        merge(src, dst, down, mid, up);
    }

    //一个数组左右半边分别有序，src归并到dst
    public void merge(T[] src, T[] dst, int down, int mid, int up) {
        assert isSorted(src, down, mid);  //断言，左右半边均有序
        assert isSorted(src, mid+1,up);

        int i = down, j = mid + 1;
        for (int k = down; k <= up; k++) {
            if (i > mid) dst[k] = src[j++]; //左半边用尽，取右半边元素
            else if (j > up) dst[k] = src[i++];
            else if (less(src[i], src[j])) //左半边元素比右半边小
                dst[k] = src[i++];
            else dst[k] = src[j++];
        }

        assert isSorted(dst, down, up);
    }


    public void insertionSort(T[] a, int down, int up) {
        for (int i = down+1; i <= up; i++) {
            for (int j = i; j >= down+1 && less(a[j], a[j-1]); j--) {
                swap(a, j, j-1);
            }
        }
    }

    /*******************************************************************************/

    //交换两个元素
    public void swap(T[] a,int i,int j) {
        T temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    //比较两个元素大小
    public boolean less(T a, T a2) {
        return a.compareTo(a2) < 0;
    }

    public boolean isSorted(T[] a) {
        int N = a.length;
        for (int i = 1; i < N; i++) {
            if (less(a[i], a[i - 1]))
                return false;
        }
        return true;
    }

    public boolean isSorted(T[] a, int down, int up) {
        for (int i = down+1; i <= up; i++) {
            if (less(a[i], a[i - 1]))
                return false;
        }
        return true;
    }

    //测试
    public static void main(String[] args) {
        Double[] a = new Double[1500];
        for (int i = 0; i < 1500; i++) {
            a[i] = Math.random();
        }
        MergeInsSort<Double> mis = new MergeInsSort<Double>();
        mis.sort(a);
        System.out.println(mis.isSorted(a));
        System.out.println(mis.isSorted(mis.array));
    }
}

测试

代码如下：

public class Test {
    //测试数据个数
    public static final int NUM = 1000000;

    public static <T> double testSort(T[] data, Sort<T> sort) {
        StopWatch timer = new StopWatch();
        sort.sort(data);
        return timer.elapsedTime();
    }

    public static void main(String[] args) {
        Double[] data1 = new Double[NUM];

        for(int i=0; i < NUM; i++) {
            data1[i] = Math.random();
        }
        Double[] data2 = data1.clone();
        Double[] data3 = data1.clone();
        Double[] data4 = data1.clone();

        //InsertionSort<Double> its = new InsertionSort<Double>();
        //SelectionSort<Double> sts = new SelectionSort<Double>();
        ShellSort<Double> sls = new ShellSort<Double>();
        MergeSort<Double> mgs = new MergeSort<Double>();
        MergeInsSort<Double> mis = new MergeInsSort<Double>();
        MergeUpSort<Double> mus = new MergeUpSort<Double>();

        System.out.println("the number of data: " + Test.NUM);
        System.out.println("MergeInsSort---->" + Test.testSort(data1,mis));
        System.out.println("MergeUpSort---->" + Test.testSort(data2,mus));
        System.out.println("MergeSort---->" + Test.testSort(data3,mgs));
        System.out.println("ShellSort---->" + Test.testSort(data4,sls));
    }
}

class StopWatch {
    public final long start;
    public StopWatch() {
        start = System.currentTimeMillis();
    }

    public double elapsedTime() {
        long now = System.currentTimeMillis();
        return (now-start)/1000.0;
    }
}

结果：
这里写图片描述

wangyl_gain
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排序算法之希尔排序
dp1041814775的博客
09-25 199
排序算法之希尔排序 前言 从此篇开始将介绍较为高级的排序算法，相信大家已经发现，前面的几篇算法的时间复杂度表现并不优秀，下面将介绍时间复杂度表现不错的几种排序算法 其中很多用到了分治法的思想，望大家多多体会 排序原理 官话： 1、选定一个增量长，按照增量长h作为数据分组的依据。对数据进行分组 2、对分好组的每一组数据完成插入排序 3、减小增量长，最小为1, ...
希尔排序和归并排序详解
weixin_47257473的博客
10-14 1182
希尔排序，又称缩小增量排序，是插入排序的的一种优化版本，其主要基本思想是....
python实现希尔排序（代码实现）
weixin_44160044的博客
11-29 299
希尔排序的实质就是分组插入排序，该方法有被称为缩小增量排序。 运作： （1）选择一个步长序列 （2）按照步长序列个数k，对排序序列进行k趟排序 （3）每趟排序，根据对应的步长ti，将待排序序列分割成ti个子序列，分别对各个子序列进行直接插入排序 def shell_sort(lis): step = len(lis)//2 #步长一般取数组总长度的一半 while step > 0: #步长大于0时，进入循环 for i in range(step,len(lis)):
希尔排序分析及代码实现
Kevin-Ding的博客
03-03 509
希尔排序
(兔C残篇)希尔排序的代码实现与讲解
tianlei_的博客
02-21 562
文章目录1. 概念1.1 傻瓜式指南1.2 举例说明2. 过程推导第一步2.1 直接插入排序的复习2.2 第一步，初改造 1. 概念 希尔排序 又称缩小增量排序。是对直接插入排序的一种优化。 它的基本思想是： 先将原表按增量 ht 进行分解，每个子文件按照直接插入法排序。同样，用下一个增量继续 ht /2 将文件再分为子文件，再按照直接插入法进行排序。直到 ht = 1 时，整个文件便排好序。 其关键在于，选择好适量的增量，例如 9 - 3 ，通过三重循环来实现。 1.1 傻瓜式指南 理解了吗？不理解
8.12-8.19-冒泡-选择-插入-希尔-快速-归并-基数-堆排序-排序算法Swift代码及UI演示
05-25
4. 希尔排序（Shell Sort）：希尔排序是插入排序的一种优化版本，通过间隔序列（也称为增量序列）减少元素间的比较距离，从而提高效率。其平均时间复杂度介于O(n)到O(n^2)之间。 5. 快速排序（Quick Sort）：快速...
Java代码-排序-直接插入排序、希尔排序、直接选择排序、冒泡排序、堆排序、快速排序、归并排序中部分排序以及算法-贪心法
05-29
Java代码-排序-直接插入排序、希尔排序、直接选择排序、冒泡排序、堆排序、快速排序、归并排序中部分排序以及算法-贪心法，大家可以将源码下载下来进行学习，附带着注释和解释，有不理解的可以找博主一起探讨，共同...
NlogN经典排序算法的实现-希尔排序，快速排序，归并排序.zip
最新发布
11-17
**希尔排序、快速排序与归并排序：NlogN经典排序算法详解** 排序算法是计算机科学中的基础且重要的一部分，尤其是在处理大量数据时，高效排序能够显著提升程序性能。本资料包聚焦于三类时间复杂度为O(nlogn)的经典...
算法-数据结构和算法-12-希尔排序.rar
09-16
希尔排序（Shell Sort）是一种基于插入排序的快速排序方法，由Donald Shell于1959年提出。它的主要思想是将待排序的元素...但由于其不稳定性，如果对稳定性有要求，可以选择其他稳定的排序算法，如归并排序或冒泡排序。
最快的排序算法 谁才是最强的排序算法：快速排序-归并排序-堆排序，排序算法数据结构
04-07
本文将对快速排序、归并排序、堆排序等常见排序算法进行比较和分析，探讨它们的优缺点和适用场景。 首先， let's 看一下这些排序算法的时间复杂度和空间复杂度： | 排序算法 | 平均情况 | 最好情况 | 最坏情况 | ...
《数据结构》-第八章 排序(知识点总结)
大家一起进步叭
09-09 4432
第八章 排序 排序作为各类数据结构的相应的运算的一种，在很多领域中都有广泛的应用。主要的排序方法有插入排序、交换排序、选择排序、二路归并排序、基数排序、外部排序等各类排序方法。堆排序、快速排序和归并排序是本章的重难点，应深入掌握各种排序算法的思想、排序过程(能动手模拟)和特征(初态的影响、复杂度、稳定性、适用性等)。 本章同样作为考察重点章节，通常以选择题的形式考查不同算法之间的对比。此外，对于一些常用排序算法的关键代码，要达到熟练编写的程度:看到某特定序列，读者应具有选择最优排序算...
数据结构第八章内排序MOOC整理
只是一个小作坊
06-04 2662
1.对于序列{E，A，S，Y，Q，U，E，S，T，I，O，N}，以{6，3，1}为增量采用Shell排序。头两趟{6，3}增量排序后，关键字的累积比较次数为()。D A.16 B.15 C.18 D.17 2.已知一组元素的排序码为(46，74，16，53，14，26，40，38，86，65，27，34)，利用直接插入排序的方法（第一个数字不用插入）,写出第四次向前面有序表插入一个元素后的排列结果。 14 16 46 53 74 26 40 38 86 65 27 34 3.已知一组元素的排序码为(46
考研题目 第十章 排序
懒王子的专栏
12-02 6273
u导读：　　C．平均时间为0（n log n）的排序方法 D．以上都不对 　　2．下面给出的四种排序法中( )排序法是不稳定性排序法。【北京航空航天大学1999 一、10 （2分）】　　A. 插入 B. 冒泡 C. 二路归并 D. 堆积　　3．下列排序算法中，其中（ ）是稳定的。 【福州大学1998 一、3
排序算法——希尔排序
Pai大的博客
09-02 372
本文整理了希尔排序相关内容，供大家参考，自己复习。
(C语言浙大版)小白实现希尔排序并分析增量序列(附测试用例)
执念斩长河
05-02 1105
本博文源于浙江大学《数据结构》，今天姥姥讲解希尔排序。希尔排序是对插入排序增量序列的扩展，如何更好的加快排序的速度，有以下的结论需要熟知：
数据结构——排序
m0_68373260的博客
12-02 660
数据结构，简单选择排序、直接插入排序、希尔排序、冒泡排序、快速排序 递归排序、堆排序、基数排序。
《数据结构》自学考试 课程代码02331 2012版 第07章 排序 例题集和编程练习
u010530400的博客
12-05 289
《数据结构》自学考试 课程代码02331 2012版 第07章 排序 例题集和编程练习
高效排序算法——希尔排序、堆排序、归并排序、快速排序
Tiko.T的部落格
04-09 4662
如标题，这里讨论的是基于比较的排序算法中最高效的三种算法和希尔排序。堆排序、归并排序、快速排序的平均时间复杂度均为O(NlogN)。前面有介绍过O(N2)的三种简单排序算法（见三大简单排序算法——插入、选择、冒泡），其中实际表现最好的要属希尔排序。可以证明通过交换相邻元素来进行排序的任何算法都需要O(N2)的平均时间，其中插入排序虽然不是通过交换来排序，但是可以等价为交换的操作，依然是O(N2)。...
GAIN
Forlogenの解忧杂货铺
05-06 9362
论文地址：https://arxiv.org/abs/1806.02920 论文GitHub：https://github.com/jsyoon0823/GAIN 收录：ICML2018 总览 这篇论文中作者提出了一种使用GAN填补缺失值的新框架GAIN，基本原理和标准的GAN相似，不同的在于根据具体问题所做的架构方面的改变。在GAIN中主要包括以下三个部分： Generator，G：它用...
C++ 不知算法系列之从希尔、归并排序算法中的分治哲学聊起
12-29
总的来说，希尔、归并、快速排序算法以及冒泡、插入、选择排序算法都是基于分治思想的经典排序算法。通过将大问题分解成小问题，再合并小问题的解，最终实现对原始问题的解答。分治算法在解决复杂问题的过程中体现了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值