【数据结构与算法 00】二分插入排序

算法思想（从小到大排序）

• 所谓二分插入排序，即插入排序基础上的优化算法，依然是将待排序数组看左右两个序列，左序列有序，有序列无序。
• 假设第一个数array[0]为有序列，那么array[1,N-1]为无序列.循环遍历无序列，找出array[i]在有序列中应该插入的位置,插入。
• 例如一个乱序数组为{1,3,2,4 ， 假如有序列为 { 1,3 } 无序列循环到2时 ，那么2在有序列中的位置应该是1 - 3 中间 ， 所以 [ 3. . .2 ) 之间的所有数据右移 ， 即3右移的2的位置 ， 腾出了3原先所在的位置 ， 由2替代
  

排序算法稳定性

• 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的

博客地址：http://blog.csdn.net/mkrcpp/article/details/39153951

import java.util.Arrays;

public class Main
{
	// 循环测试次数
	public static int LOOP_COUNT = 100;
	public static int ARRAY_SIZE = 10000;

	public static void main(String[] args)
	{
		int[] mArray = Common.getArray(ARRAY_SIZE);
		int allTime = 0;
		for (int i = 0; i < LOOP_COUNT; i++)
		{
			// 拷贝数组
			int[] tmpArray = Arrays.copyOf(mArray, ARRAY_SIZE);
			long tmpTime = System.currentTimeMillis();
			execute(tmpArray);
			allTime += System.currentTimeMillis() - tmpTime;
		}
		System.err.println("数组大小为(" + ARRAY_SIZE + ")的" + LOOP_COUNT + "次二分插入排序的平均耗时为：" + allTime / (float) LOOP_COUNT);

	}

	/***
	 * @title 二分插入排序
	 * @description 所谓二分插入排序，即插入排序基础上的优化算法，依然是将待排序数组看左右两个序列，左序列有序，有序列无序。
	 *              假设第一个数array[0]为有序列，那么array[1,N-1]为无序列.循环遍历无序列，找出array[i]
	 *              在有序列中应该插入的位置,插入。<br/>
	 *              例如一个乱序数组为{1,3,2,4 ， 假如有序列为 { 1,3 } 无序列循环到2时 ，
	 *              那么2在有序列中的位置应该是1 - 3 中间 ， 所以 [ 3. . .2 ) 之间的所有数据右移 ， 即3
	 *              右移的2的位置 ， 腾出了3原先所在的位置 ， 由2替代
	 * @author michael.mao
	 * @date 2014年9月5日 下午2:42:29
	 * @version V1.0
	 */
	public static void execute(int[] array)
	{
		for (int i = 1; i < array.length; i++)
		{
			int tmpV = array[i];
			int mid = 0, left = 0, right = i - 1;

			// 在有序列中找出，当前无序列元素(tmpV=array[i])应该插入的位置
			while (right >= left)
			{
				mid = (left + right) / 2;// 中
				if ( tmpV > array[mid] )
					left = mid + 1;
				else
					right = mid - 1;
			}
			// 腾出位置等待插入
			for (int j = i; j > left; j--)
				array[j] = array[j - 1];
			// 插入到腾出的位置(改进,相同的数不交换,实现稳定排序)
			if ( array[left] != tmpV )
			{
				array[left] = tmpV;
				System.err.println("发生一次交换");
			}
		}
	}
}

案例结果：

原始数组：02 02 02 03 03 02 01 
-----------------------------
当前序列：02 02 02 03 03 02 01
位移序列：02 02 02 03 03 02 01 
-----------------------------
当前序列：02 02 02 03 03 02 01 
位移序列：02 02 02 03 03 02 01 
-----------------------------
当前序列：02 02 02 03 03 02 01 
位移序列：02 02 02 03 03 02 01 
-----------------------------
当前序列：02 02 02 03 03 02 01 
位移序列：02 02 02 02 03 03 01 
-----------------------------
当前序列：02 02 02 02 03 03 01 
位移序列：01 02 02 02 02 03 03 
发生一次交换(上面execute方法最后一行只执行了一次，即相同的数没有交换)

由此可见本排序算法为稳定排序！