排序算法 插入排序(直接插入排序、半插入排序、希尔排序)

一、直接插入排序。

1、介绍。

直接插入排序是一种简单的插入排序法,其基本思想是:把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中,直到所有的记录插入完为止,得到一个新的有序序列。例如,已知待排序的一组记录是:60,71,49,11,24,3,66。假设在排序过程中,前3个记录已按关键码值递增的次序重新排列,构成一个有序序列:49,60,71。将待排序记录中的第4个记录(即11)插入上述有序序列,以得到一个新的含4个记录的有序序列。首先,应找到11的插入位置,再进行插入。可以将11放入数组的第一个单元r[0]中,这个单元称为监视哨,然后从71起从右到左查找,11小于71,将71右移一个位置,11小于60,又将60右移一个位置,11小于49,又再将49右移一个位置,这时再将11与r[0]的值比较,11≥r[0],它的插入位置就是r[1]。假设11大于第一个值r[1]。它的插入位置应该在r[1]和r[2]之间,由于60已经右移了,留出来的位置正好留给11.后面的记录依照同样的方法逐个插入到该有序序列中。若记录数n,续进行n-1趟排序,才能完成。

直接插入排序是稳定排序,不需要额外内存,空间复杂度O(1)。时间复杂度,最佳情况:O(n)  最差情况:O(n^2)  平均情况:O(n^2)。

2、步骤。

(1)设置监视哨r[0],将待插入记录的值赋值给r[0];
    (2)设置开始查找的位置j;
    (3)在数组中进行搜索,搜索中将第j个记录后移,直至r[0].key≥r[j].key为止;
    (4)将r[0]插入r[j+1]的位置上。

3、代码。

  1. public static void main(String[] args) {

  2.  

    System.out.println("------开始------");

  3.  

    //生成生成两份一模一样的随机数组,其中一组用系统自带的方法进行排序,到时候进行验证。

  4.  

    final int number = 100000;

  5.  

    int[] sortArray = new int[number];

  6.  

    int[] sortArrayCopy = new int[number];

  7.  

    for (int i = 0; i < sortArray.length; i++) {

  8.  

    sortArray[i] = (int) (Math.random() * number);

  9.  

    }

  10.  

    System.arraycopy(sortArray, 0, sortArrayCopy, 0, number);//数组复制

  11.  

    Arrays.sort(sortArrayCopy);

  12.  

  13.  

    //开始排序

  14.  

    long startTime = System.currentTimeMillis();

  15.  

    directInsertSort(sortArray);//直接插入排序

  16.  

    System.out.println("花费时间:" + (System.currentTimeMillis() - startTime));

  17.  

  18.  

    //跟系统排序之后数组进行比较,查看是否排序成功。

  19.  

    if (Arrays.equals(sortArray, sortArrayCopy)) {

  20.  

    System.out.println("排序成功");

  21.  

    } else {

  22.  

    System.out.println("排序失败");

  23.  

    }

  24.  

    System.out.println("------结束------");

  25.  

    }

  1. //直接插入排序 最佳情况:T(n) = O(n) 最坏情况:T(n) = O(n2) 平均情况:T(n) = O(n2)

  2.  

    private static void directInsertSort(int[] array) {

  3.  

    for (int i = 1; i < array.length; i++) {//n-1轮 第一个无需排序

  4.  

    int curIndex = i;

  5.  

    while (curIndex > 0) {

  6.  

    if (array[curIndex] > array[curIndex - 1]) {

  7.  

    break;

  8.  

    }

  9.  

    int flag = array[curIndex];

  10.  

    array[curIndex] = array[curIndex - 1];

  11.  

    array[curIndex - 1] = flag;

  12.  

    curIndex--;

  13.  

    }

  14.  

    }

  15.  

    }

4、结果。

二、折半插入排序。

1、介绍。

将直接插入排序中寻找A[i]的插入位置的方法改为采用折半比较,即可得到折半插入排序算法。在处理A[i]时,A[0]……A[i-1]已经按关键码值排好序。所谓折半比较,就是在插入A[i]时,取A[i-1/2]的关键码值与A[i]的关键码值进行比较,如果A[i]的关键码值小于A[i-1/2]的关键码值,则说明A[i]只能插入A[0]到A[i-1/2]之间,故可以在A[0]到A[i-1/2-1]之间继续使用折半比较;否则只能插入A[i-1/2]到A[i-1]之间,故可以在A[i-1/2+1]到A[i-1]之间继续使用折半比较。如此担负,直到最后能够确定插入的位置为止。一般在A[k]和A[r]之间采用折半,其中间结点为A[k+r/2],经过一次比较即可排除一半记录,把可能插入的区间减小了一半,故称为折半。执行折半插入排序的前提是文件记录必须按顺序存储。

折半插入排序是稳定排序,不需要额外内存,空间复杂度O(1)。时间复杂度,最佳情况:O(n^2)  最差情况:O(n^2)  平均情况:O(n^2)。

2、步骤。

跟直接插入排序的步骤相似,只不过查找插入点的方法不一样。直接插入排序是从有序区的最后一个数依次向前找,而折半插入排序是通过折半的方式进行查找。

(1)计算 0 ~ i-1 的中间点,用 i 索引处的元素与中间值进行比较,如果 i 索引处的元素大,说明要插入的这个元素应该在中间值和刚加入i索引之间,反之,就是在刚开始的位置 到中间值的位置,这样很简单的完成了折半;
    (2)在相应的半个范围里面找插入的位置时,不断的用(1)步骤缩小范围,不停的折半,范围依次缩小为 1/2 1/4 1/8 .......快速的确定出第 i 个元素要插在什么地方;
    (3)确定位置之后,将整个序列后移,并将元素插入到相应位置。

3、代码。

  1. public static void main(String[] args) {

  2.  

    System.out.println("------开始------");

  3.  

    //生成生成两份一模一样的随机数组,其中一组用系统自带的方法进行排序,到时候进行验证。

  4.  

    final int number = 100000;

  5.  

    int[] sortArray = new int[number];

  6.  

    int[] sortArrayCopy = new int[number];

  7.  

    for (int i = 0; i < sortArray.length; i++) {

  8.  

    sortArray[i] = (int) (Math.random() * number);

  9.  

    }

  10.  

    System.arraycopy(sortArray, 0, sortArrayCopy, 0, number);//数组复制

  11.  

    Arrays.sort(sortArrayCopy);

  12.  

  13.  

    //开始排序

  14.  

    long startTime = System.currentTimeMillis();

  15.  

    halveInsertSort(sortArray);//折半插入排序

  16.  

    System.out.println("花费时间:" + (System.currentTimeMillis() - startTime));

  17.  

  18.  

    //跟系统排序之后数组进行比较,查看是否排序成功。

  19.  

    if (Arrays.equals(sortArray, sortArrayCopy)) {

  20.  

    System.out.println("排序成功");

  21.  

    } else {

  22.  

    System.out.println("排序失败");

  23.  

    }

  24.  

    System.out.println("------结束------");

  25.  

    }

  1. //折半插入排序 最佳情况:T(n) = O(n) 最坏情况:T(n) = O(n2) 平均情况:T(n) = O(n2)

  2.  

    private static void halveInsertSort(int[] array) {

  3.  

    int flag;

  4.  

    int low, middle, high;

  5.  

    for (int i = 1; i < array.length; i++) {//n-1轮

  6.  

    flag = array[i];

  7.  

    low = 0;

  8.  

    high = i - 1;

  9.  

    while (low <= high) {//最后的情况就是low==high==middle的判断

  10.  

    middle = (low + high) / 2;

  11.  

    if (array[i] > array[middle]) {

  12.  

    low = middle + 1;

  13.  

    } else {

  14.  

    high = middle - 1;

  15.  

    }

  16.  

    }

  17.  

    for (int j = i; j > high + 1; j--) {

  18.  

    array[j] = array[j - 1];

  19.  

    }

  20.  

    array[high + 1] = flag;

  21.  

    }

  22.  

    }

4、结果。

三、希尔排序。

1、介绍。

希尔排序(Shell‘s Sort)是插入排序的一种又称“缩小增量排序”(Diminishing Increment Sort),是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。

希尔排序是不稳定排序,不需要额外内存,空间复杂度O(1)。时间复杂度,最佳情况:O(nlog^2n)  最差情况:O(nlog^2n)  平均情况:O(nlogn)。

2、步骤。

我们来看下希尔排序的基本步骤,在此我们选择增量gap=length/2,缩小增量继续以gap = gap/2的方式,这种增量选择我们可以用一个序列来表示,{n/2,(n/2)/2...1},称为增量序列。希尔排序的增量序列的选择与证明是个数学难题,我们选择的这个增量序列是比较常用的,也是希尔建议的增量,称为希尔增量,但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,具体算法描述:选择一个增量序列t1,t2,…,tk,其中ti>tj,tk=1;按增量序列个数k,对序列进行k 趟排序;每趟排序,根据对应的增量ti,将待排序列分割成若干长度为m 的子序列,分别对各子表进行直接插入排序。仅增量因子为1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。

3、代码。

  1. public static void main(String[] args) {

  2.  

    System.out.println("------开始------");

  3.  

    //生成生成两份一模一样的随机数组,其中一组用系统自带的方法进行排序,到时候进行验证。

  4.  

    final int number = 100000;

  5.  

    int[] sortArray = new int[number];

  6.  

    int[] sortArrayCopy = new int[number];

  7.  

    for (int i = 0; i < sortArray.length; i++) {

  8.  

    sortArray[i] = (int) (Math.random() * number);

  9.  

    }

  10.  

    System.arraycopy(sortArray, 0, sortArrayCopy, 0, number);//数组复制

  11.  

    Arrays.sort(sortArrayCopy);

  12.  

  13.  

    //开始排序

  14.  

    long startTime = System.currentTimeMillis();

  15.  

    shellInsertSort(sortArray);//希尔插入排序

  16.  

    System.out.println("花费时间:" + (System.currentTimeMillis() - startTime));

  17.  

  18.  

    //跟系统排序之后数组进行比较,查看是否排序成功。

  19.  

    if (Arrays.equals(sortArray, sortArrayCopy)) {

  20.  

    System.out.println("排序成功");

  21.  

    } else {

  22.  

    System.out.println("排序失败");

  23.  

    }

  24.  

    System.out.println("------结束------");

  25.  

    }

  1. //希尔插入排序 最佳情况:T(n) = O(nlog2 n) 最坏情况:T(n) = O(nlog2 n) 平均情况:T(n) =O(nlog2n) 

  2.  

    private static void shellInsertSort(int[] array) {

  3.  

    int groups = array.length / 2;//增量,一共的组数

  4.  

    while (groups > 0) {

  5.  

    //将groups看作1,就会跟直接插入排序的算法一模一样

  6.  

    for (int i = groups; i < array.length; i++) {//n-1轮 第一个无需排序

  7.  

    int curIndex = i;

  8.  

    while (curIndex > groups - 1) {

  9.  

    if (array[curIndex] > array[curIndex - groups]) {

  10.  

    break;

  11.  

    }

  12.  

    int flag = array[curIndex];

  13.  

    array[curIndex] = array[curIndex - groups];

  14.  

    array[curIndex - groups] = flag;

  15.  

    curIndex -= groups;

  16.  

    }

  17.  

    }

  18.  

    groups /= 2;

  19.  

    }

  20.  

    }

4、结果。

原文地址:https://www.cnblogs.com/sxdj/p/11741965.html

时间: 2024-11-06 07:23:31

排序算法 插入排序(直接插入排序、半插入排序、希尔排序)的相关文章

#排序算法#【2】直接插入排序、希尔排序

直接插入排序法 插入排序的算法描述是一种简单直观的排序算法.它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入.插入排序在实现上,在从后向前扫描过程中,需要反复把已排序元素逐步向后移动,为最新元素提供插入空间. 核心代码: //直接插入排序法 void InsertSort(int a[],int n){ int i,j,k,t; for(i = 1 ; i<n;i++){ k = a[i]; /* 第一次比较粗糙的写法 j = i-1; while(

【数据结构】——排序算法——1.1、直接插入排序

插入算法很多,无论是在内功修炼,各种笔试面试都是相当有用的.接下来,将陆续将各种排序算法进行练习: 主要分为以下几个部分(其他后面学习补充): 一.插入类排序:1.直接插入排序:2.折半插入排序:3.希尔shell排序: 二.交换类排序:1.冒泡排序 :2.快速排序: 三.选择类排序:1.简单选择: 2.堆排序: 本人多使用Java--开始吧! 首先推荐1.维基百科<排序算法>词条,图文并茂,很形象!2.学习博文<维基百科上的算法和数据结构链接很强大>,资料很多,保存学习! [数据

图形化排序算法比较:快速排序、插入排序、选择排序、冒泡排序

图形化排序算法比较:快速排序.插入排序.选择排序.冒泡排序

常见的五类排序算法图解和实现(多关键字排序:基数排序以及各个排序算法的总结)

基数排序思想 完全不同于以前的排序算法,可以说,基数排序也叫做多关键字排序,基数排序是一种借助“多关键字排序”的思想来实现“单关键字排序”的内部排序算法. 两种方式: 1.最高位优先,先按照最高位排成若干子序列,再对子序列按照次高位排序 2.最低位优先:不必分子序列,每次排序全体元素都参与,不比较,而是通过分配+收集的方式. 多关键字排序 例:将下表所示的学生成绩单按数学成绩的等级由高到低排序,数学成绩相同的学生再按英语成绩的高低等级排序.        第一个关键字是数学成绩,第二个关键字是英

超级具体解读基本排序算法(不看懊悔,带排序演示动画)

排序与我们日常生活中息息相关.比方.我们要从电话簿中找到某个联系人首先会依照姓氏排序.买火车票会依照出发时间或者时长排序.买东西会依照销量或者好评度排序.查找文件会依照改动时间排序等等.在计算机程序设计中,排序和查找也是最主要的算法,非常多其它的算法都是以排序算法为基础,在一般的数据处理或分析中.通常第一步就是进行排序,比方说二分查找.首先要对数据进行排序.在Donald Knuth 的计算机程序设计的艺术这四卷书中.有一卷是专门介绍排序和查找的. 排序的算法有非常多.在维基百科上有这么一个分类

三种线性排序算法(计数、基数、桶排序)的简单实现

一.计数排序 计数排序假设n个输入元素中的每一个都是介于0到k之间的整数.此处k为某个整数(输入数据在一个小范围内). 基本思想: 计数排序的基本思想是对每一个输入元素x,确定出小于x的元素的个数.然后再将x直接放置在它在最终输出数组中的位置上. 如下图所示: 由于数组中可能有相等的数,在处理时需要注意. 时间复杂度和空间复杂度分析 算法总时间Θ(k + n).当k=O(n)时,计数排序的运行时间是Θ(n). 空间复杂度是O(n+k).需要两个辅助数组:存放排序结果的数组B[n],存放临时结果的

排序算法: 插入排序法(直接插入法和希尔排序法)

1, 直接插入法:每次从无序表中取出第一个元素,把它插入到有序表的合适位置,使有序表仍然有序.由于碰见一个和插入元素相等的,那么插入元素把想插入的元素放在相等元素的后面.所以,相等元素的前后顺序没有改变,从原无序序列出去的顺序就是排好序后的顺序,所以插入排序是稳定的. 实现思路: 1,把第一个数看成有序序列,从数组第二个开始向后遍历,即i=1,外层循环标识并决定待比较的数值,内层循环为待比较数值确定其最终位置; 2,当从第i个数向前遍历时,将a[i]保存在temp中,然后令j=i,首先temp与

数据结构与算法之排序算法(一):插入排序

插入排序可以分为:直接插入排序和希尔排序(已知元素,找位置) 1.直接插入排序 原理:将一个未排序数组分为无序区和有序区,不断将无序区的第一个元素按照大小插入到有序区,最后直到无序区的元素都插入到有序区,排序完成. 代码实现: for(int i = 1; i < a.length; i++){ //无序区开始下标 if(a[i] < a[i-1]){//判断是否应排序 int currentValue = a[i];//将a[i]临时存储起来 int j = i-1; //两个条件的顺序不能

排序算法总结(一)插入排序【Insertion Sort】

最近在忙着找工作,以前看的排序算法都忘记了,悲剧啦T  T现在来回顾一下吧. 这边推荐一个算法可视化的网站,非常有用.http://visualgo.net/ 一.插入排序的思想(Wikipedia): 它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入.插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间. 从第一个元素开始,该元素可以

常见的排序算法(五):插入排序

插入排序(英语:Insertion Sort)是一种简单直观的排序算法.它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入.插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间. 一般来说,插入排序都采用in-place在数组上实现.具体算法描述如下: 从第一个元素开始,该元素可以认为已经被排序 取出下一个元素,在已经排序的元素序列中从后