数据结构与算法-插入排序与希尔排序

每个人的算法实现可能不同，但是一定要掌握其排序思想。冒泡，选择，插入是程序员必须会手写的普通算法。

插入排序

插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。

插入排序法思想

插入排序（Insertion Sorting）的基本思想是：把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有 序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排 序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

插入排序思路图

插入的位置条件判断：

1. 无序表的值第一次大于有序表中的某一个值。
2. 无序表的值本身就是最大值。

插入排序法应用实例

[101, 34, 119, 1 ]请从小到大排序
代码实现

package my.sort;

public class InsertSort {
	public static void main(String[] args) {
		int[] arr= {2,5,12,2,6,22,11,99,3};
		sort(arr);
		for(int data: arr) {
			System.out.println(data);
		}
	}
	public static void sort(int[] arr) {
		int length=arr.length;
		int insertIndex=0;
		int insertValue=0;
		//要求从小到大排序。
		for(int i=1; i<length; i++) {
			//insertIndex: 要插入的可能位置，这里指向了有序表的最后一位。
			insertIndex=i-1;
			//insertValue: 表示无序表插入到有序表的一个元素值。
			insertValue=arr[i];
			//这个while循环找到要插入的元素的位置在哪。具体坐标的为insertIndex.
			//insertIndex>=0 :表示已经到了有序表的表头了。前面没有元素了。
			//insertValue<arr[insertIndex]：表示要插入的值比有序表的arr[insertIndex]的值小-->
			//这里要找到 一个位置：就是插入元素的值比某一元素大的时候，退出该循环。即 insertValue>=arr[insertIndex]
			//即找到了要插入的位置，坐标为insertIndex.
			while(insertIndex>=0 && insertValue <arr[insertIndex]) {
				//值向后移动一位。
				arr[insertIndex+1]=arr[insertIndex];
				//坐标向前移动一位
				insertIndex--;
			}
			//当无序表本身就是最大元素时，就不用进行操作。
			if(insertIndex+1 != i) {
				arr[insertIndex+1]=insertValue;
			} 
		}
		
	}
}

希尔排序

插入排序存在的问题

我们看简单的插入排序可能存在的问题. 数组 arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是：
{2,3,4,5,6,6}
{2,3,4,5,5,6}
{2,3,4,4,5,6}
{2,3,3,4,5,6}
{2,2,3,4,5,6}
{1,2,3,4,5,6}
问题：当需要插入的数值又小，且又在无序表中靠后时，有序表后移的次数明显增多。

希尔排序法介绍

希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本。

希尔排序法基本思想

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；
随着增量逐渐减少，每组包含 的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。
有点“分而治之”思想的味道，将拆分为多组数据进行排序，再将多组数据合并起来；

希尔排序法的示意图

希尔排序法举例

[8,9,1,7,2,3,5,4,6,0]请从小到大排序. 请分别使用

1. 希尔排序时， 对有序序列在插入时采用交换法, 并测试排序速度.
2. 希尔排序时， 对有序序列在插入时采用移动法, 并测试排序速度
   这里很明显，基于交换法的速度明显会慢于移动法。
3. 代码实现

package my.sort;

import java.util.Arrays;

public class ShellSort {
	public static void main(String[] args) {
		int[] arr= {1,2,5,6,3,7,4,0,9,8,20,50,38,28,27,19,48,29,21,23,47};
		//sort(arr);
		sort2(arr);
	}
	private static void sort2(int[] arr) {
		// TODO Auto-generated method stub
		int temp=0; 
		int insertIndex=0;  
		int insertVal=0;
		for(int gap=arr.length/2; gap>0; gap/=2) {
			//gap表示每隔元素的间距。
			//如果gap=2,那么{0,2,4,6,8}号元素为一组， {1,3,5,7,9}号元素为一组。，并使用插入排序进行排序。
			//如果gap=5,那么{0,5}一组，{1,6}一组，{2,7}一组，{3,8}一组，{4,9}一组。
			for(int i=gap; i<arr.length; i++) {  
				
				//1.一开始，i=2,有序表只有 0号元素， 无序表有2,4,6，8号元素。
				//2.insertIndex: 要插入的可能位置，这里指向了有序表的最后一位。 一开始指向了0
				//3. insertValue: 表示无序表插入到有序表的一个元素值。 
				insertIndex=i-gap; 
				insertVal=arr[i];
				//这个while循环找到要插入的元素的位置在哪。具体坐标的为insertIndex.
				//insertIndex>=0 :表示已经到了有序表的表头了。前面没有元素了。
				//insertValue<arr[insertIndex]：表示要插入的值比有序表的arr[insertIndex]的值小-->
				//这里要找到 一个位置：就是插入元素的值比某一元素大的时候，退出该循环。即 insertValue>=arr[insertIndex]
				//即找到了要插入的位置，坐标为insertIndex+gap.
				while(insertIndex>=0 && insertVal<arr[insertIndex]) {
					//有序表向后移动一位，间距gap为5，2，1， gap表示每隔元素的间距。
					arr[insertIndex+gap]=arr[insertIndex];
					insertIndex-=gap;
				}
				//当无序表本身就是最大元素时，就不用进行操作。
				if(insertIndex+gap != i) {
					arr[insertIndex+gap]=insertVal;
				}
			}
		}
		System.out.println(Arrays.toString(arr));
	}
	private static void sort(int[] arr) {
		// TODO Auto-generated method stub
		int temp=0;
		for(int gap=arr.length/2; gap>0; gap/=2) {
			for(int i=gap; i<arr.length;i++) {
				for(int j=i-gap; j>=0;j-=gap) {
					if(arr[j] > arr[j+gap]) {
						temp=arr[j];
						arr[j]=arr[j+gap];
						arr[j+gap]=temp;
					}
				}
			}
		}
		
		
		
	}
}