排序算法之插入排序

插入排序是一种简单直观的排序方法，基本思想：每次将一个待排序的记录，按其 关键字大小插入到前面已经

排好序的子序列中，直到全部记录插入完成。

插入排序分为直接插入排序、折半插入排序、希尔排序。

直接插入排序：

public static int[] InsertSort(int[] array)
	{
		int[] newArray = Arrays.copyOf(array, array.length); // 拷贝原数组
		for (int i=1; i<newArray.length; i++) // 只有一个元素时，不需要移动
		{
			int tmp = newArray[i]; // 新遍历的值，等待插入到前面的有序数组
			int j;
			for (j=i-1; j>=0; j--)
			{
				// 将大于tmp的数，往后移动
				if (newArray[j] > tmp)
				{
					newArray[j+1] = newArray[j];
				}
				else
				{
					// 找到待插入的位置，退出循环
					break;
				}
			}
			newArray[j+1] = tmp;
		}
		return newArray;
	}

稳定性：由于每次插入元素时总是从后向前比较再移动，所以不会出现相同元素相对位置发生变化的情况，即

直接插入排序是一种稳定的排序方法。

适用性：适用于顺序存储和链式存储的线性表。当为链式存储时，可以从前往后查找指定元素的位置。

折半插入排序：

public static int[] InsertSort(int[] array)
	{
		int[] newArray = Arrays.copyOf(array, array.length);
		for (int i=1; i<newArray.length; i++)
		{
			int tmp = newArray[i]; // 新遍历的值，等待插入到前面的有序数组
			int low = 0;
			int high = i-1; // 设置折半查找的范围
			int mid = 0;
			while (low <= high)
			{
				mid = (low + high) / 2; //取中间点
				if (newArray[mid] > tmp) // 查找左半子表
				{
					high = mid - 1;
				}
				else if (newArray[mid] < tmp) // 查找右半子表
				{
					low = mid + 1;
				}
				else
				{
					break;
				}
			}
			// 统一后移元素，空出插入位置
			for (int j=i-1; j>high; j--) 
				newArray[j+1] = newArray[j];
			newArray[high+1] = tmp;
		}
		return newArray;
	}

折半插入排序减少了比较元素的次数，约为O(nlog2n)。它仍然是一个稳定的排序算法。

希尔排序：

	public int[] shellSort(int[] array)
	{
		int[] newArray = Arrays.copyOf(array, array.length);
		int d = newArray.length / 2; // d为增量, 默认增量是6
		while (true)
		{
			for (int i=0; i<d; i++) // 增量是从0到d
			{
				for (int j=i; j+d<newArray.length; j+=d)
				{
					for (int k=i; k+d<newArray.length; k+=d)  // 和上一个for循环，构成冒泡排序
					{
						int tmp; // 临时变量
						if (newArray[k] > newArray[k+d])
						{
							tmp = newArray[k];
							newArray[k] = newArray[k+d];
							newArray[k+d] = tmp;
						}
					}
				}
			}
			System.out.println("增量d:"+ d + "  " +Arrays.toString(newArray));
			if (d < 2)
			{
				break;
			}
			d -= 1;
		}
		return newArray;
	}

希尔排序是一个不稳定的排序方法，仅适用于当线性表为顺序存储的情况。