Java排序算法 ——直接插入排序和希尔排序的代码实现与分析

直接插入排序

核心思想:

  1. 将数组分为未排序区间和已排序区间
  2. 每次从未排序区间获取第一个元素,与已排序区间元素从右往左的比较,直到找到正确的索引位置,将元素插入此位置

具体实现方法有两种

整体后移

假定未排序区间的第一个元素为num,则已排序区间内大于num的元素都往后移动一位,直到遇到一个索引位置,这个位置的前一个元素小于num,则当前位置就是num的正确位置,插入元素num的值

package dataStructure;

public class directSort {
    public static void main(String[] args) {
        int[] a={9,25,12,2};
        for (int i = 1; i < a.length; i++) {
            int num = a[i];
            int j;
            for (j = i; j > 0 && num < a[j - 1]; j--) {
                a[j] = a[j - 1];
            }
            a[j] = num;
        }
        for (int i : a) {
            System.out.print(i+" ");
        }

        System.out.println();
}

i为未排序区间的第一个元素的索引位置,num为未排序区间的第一个元素的值
i 的作用是每次从未排序区间选择第一个元素,然后将这个元素加入到已排序区间,是利用 j 来进行比较和排序的

j-1为已排序区间的每一个元素(因为一开始 j=i,所以 j-1 就来到了已排序区间)
外层for循环用来获取每次未排序区间的第一个元素
内层for循环用来拿num和已排序区间的元素从右到左的进行比较,如果num小于已排序区间的元素
则将已排序区间的元素像右移动,所以是a[j] = a[j - 1];这样直接赋值,而不是交换
这样一直到num大于某个已排序区间的元素,此时停下来,内层for循环终止,此时 j 的索引位置就是num的正确位置
然后是a[j] = num;将一开始的num值放在找到的a[j]位置上

分析一下内层for循环的比较条件
内层for循环的比较条件是j > 0 && num < a[j - 1],因为 j=1 的时候就已经与 [j-1] 也就是位置0的元素比较过了。如果j继续减一,就会出现数组越界,[j-1]的值为-1了
num < a[j - 1],从右往左的与已排序区间的元素进行比较,如果一开始num大于已排序区间的最后一个元素。说明就大于已排序区间的所有元素,不用再去比较,终止内层for循环

两两交换

每次从未排序区间找到第一个元素,然后将元素加入到已排序区间里面。此时已排序区间由于多了一个元素不再有序,因此用两两比较的方式重新进行排序

package dataStructure;

public class directSort {
    public static void main(String[] args) {
        int[] b={3,6,2,4,1};
        for (int i = 0; i < b.length - 1; i++) {
            for (int j = i + 1; j > 0; j--) {
                if (b[j] < b[j - 1]) {
                    int temp = b[j];
                    b[j] = b[j - 1];
                    b[j - 1] = temp;
                }
            }
        }
        for (int i : b) {
            System.out.print(i+" ");
        }
    }
}

上面那种方式是将大于num的数字集体后移,直到num遇到一个小于num的数,停留的位置就是正确的索引位置。将num的值放在这个索引位置上,即可完成这次排序

而这个方法是两两比较,类似于冒泡排序,但不是冒泡排序
外层for循环还是用来指定要比较几次,如果数组一共有10个数,那么只需要比较9次即可
内层for循环,j=i+1用来找到未排序区间的第一个元素(假定还叫num),然后从这个元素开始向左,两两比较。

希尔排序

package dataStructure;


public class shellSort {
    public static void main(String[] args) {
        int[] arr = {32, 9, 3, 42, 26, 7, 55, 2};
        for (int step = arr.length / 2; step > 0; step /= 2) {
            //对一个步长区间进行比较 [step,arr.length)
            for (int i = step; i < arr.length; i++) {
                int value = arr[i];
                int j;
                for (j = i - step; j >= 0 && arr[j] > value; j -= step) {
                    arr[j + step] = arr[j];
                }
                arr[j + step] = value;
            }
        }
        for (int i : arr) {
            System.out.print(i+" ");
        }

    }
}

Java排序算法 ——直接插入排序和希尔排序的代码实现与分析_第1张图片

又到了郁闷的画图时间,画的略丑
Java排序算法 ——直接插入排序和希尔排序的代码实现与分析_第2张图片
总之第一重循环,用来控制step,初开始step的值为arr.length/2 ,即为4
那么一组里面只有两个值,比如第一组就是索引为0和4的元素

第二重循环,用来控制 i,选择是第几组的元素进行比较排序
一开始 i 为4,而 j 为 i-step 即为0

第三重循环,用来控制 j,作用是完成组内元素的比较排序
当组内元素只有两个时,循环的作用就是两两交换,较大的值放在后面。

比较完成后,i ++ ,变成5,然后 j=i-step 变成1,也就是比较下一组两两元素。就这样一直比较下去,直到不满足 i 循环的条件。然后开始第一重 step 循环的第二轮 ,此时step折半变成 2
在这里插入图片描述
一组里面不止一个元素了,根据step为2进行分组,一组里面有四个元素

i 循环开始第一轮,此时 i 为2,然后 j 为0,比较排序后,第一组并没有比较完毕,因为一共有四个元素,这里只是比较了两个元素。但是 i++后开始比较下一组,[7,2,9,42] 这一组,直到再次 i ++,i 为 4的时候,才再次回来比较第一组的元素。

这里需要注意的是,此时的第三重循环,j 的循环,里面有三个元素,变成了直接插入排序

i = 2 的时候,比较了两个元素,这两个元素构成了已排序区间,当 i = 4的时候,指向的元素是 32,这个32 就相当于未排序区间的第一个元素,利用第三重 j 循环,进行直接插入排序,采取的手段是整体后移。直到这三个元素比较完毕后,第三重 j 循环结束,i ++ 继续比较[2,7,9,42]这一组,注意这里是2,7,第二组的前两个元素被排序过了

为了便于理解,结合代码详细说一下

for (j = i - step; j >= 0 && arr[j] > value; j -= step) {
    arr[j + step] = arr[j];
}
arr[j + step] = value;

这里的 j = i - step 就是指向已排序区间的最后一个元素,而 j + step 就是指向未排序区间的第一个元素。
arr[j + step] = arr[j]; 采取的就是整体后移的方式,将前面较大的元素赋值给后面
比如 i=4时,j = i - step 为2,value = arr[4],如果 arr[2] > value,则arr[4] = arr[2]
然后 j = j - step = 0,如果arr[0] > value,则 arr[2] = arr[0]

最后arr[j + step] = value; arr[0] = value,这里arr[j+step] 为 arr[0] 是因为上一轮循环后 j = j - step 为 -2 ,所以要加 step 变成 0

你可能感兴趣的:(数据结构与算法,排序算法,java,直接插入排序,希尔排序)