排序算法java实现--插入法

        排序是接触算法导论的时候最先接触的算法，也是学生时代打交道最多的算法。这几天把几种不同的算法好好回忆一下，包括自己最不熟悉的外排序。

         插入排序算法，包括直接插入排序，二分插入排序和希尔排序。

        直接上代码

         main函数：

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] is = new int[MAX];
		int[] shell = new int[MAX / 2];
		for (int i = 0; i < shell.length; i++) {
			if (i == 0) {
				shell[i] = MAX / 2;
			} else {
				shell[i] = shell[i - 1] / 2;
			}
		}
		shell[shell.length - 1] = 1;
		for (int i = 0; i < MAX; i++) {
//			is[i] = new Random().nextInt(MAX);
//			is[i] = i;
			is[i] = MAX - i;
		}
		long start = System.currentTimeMillis();
		
		shellSort(is, shell);
//		directSort(is);
//		binarySort(is);
		long end = System.currentTimeMillis();
		System.out.println("程序执行了" + (end - start) + "毫秒");
	}

 

          直接插入排序：

/**
	 * @Title: directSort
	 * @Description: TODO(直接排序)
	 * @param 设定文件
	 * @return void 返回类型
	 */
	public static void directSort(int[] is) {
		/**
		 * 第0个是已经排好序的，所以从第一个开始插入
		 */
		for (int i = 1; i < is.length; i++) {
			/**
			 * 每一个元素与前边已经排好的元素做比较
			 */
			int k;
			int temp = is[i];
			for (k = i - 1; k >= 0 && is[k] > temp; k--) {
				is[k + 1] = is[k];
			}
			is[k + 1] = temp;
		}
	}

 直接插入排序的思想最容易理解，就是设想第i个元素前边是已经排序好的数列，像插扑克牌一样，从后往前对比，把第i个元素插到合适的位置。

对100万个随机数进行排序，直插法耗时1分56秒

程序执行了116072毫秒

 对100万个已经排序的数组进行排序，直插法耗时5毫秒。。。

 

 

对100万个逆序的数组进行排序，直插法耗时6分钟。。。

程序执行了249916毫秒

     二分插入排序：

    

/**
	 * @Title: binarySort
	 * @Description: TODO(二分插入排序)
	 * @param @param is 设定文件
	 * @return void 返回类型
	 */
	private static void binarySort(int[] is) {
		/**
		 * 第0个是已经排好序的，所以从第一个开始插入
		 */
		for (int i = 1; i < is.length; i++) {
			/**
			 * 每一个元素与前边已经排好的元素做比较
			 */
			int temp = is[i];
			int left = 0;
			int right = i - 1;
			int mid = (left + right) / 2;
			while (left <= right) {
				if (temp > is[mid]) {
					left = mid + 1;
				} else {
					right = mid - 1;
				}
				mid = (left + right) / 2;
			}
			reverse(is, i, left);
		}
	}

           这种方法也是设想第i个元素前边是已经排序好的数列，不过在插入的时候不是用插纸牌的方法，而是用二分查找的手段，从中间查第i个纸牌应该插入的位置，然后插进去。这种方法比直接插入优越的地方在于如果是乱序的，那么查找的时候时间复杂度只有O(logn)。

           二分插入法排序1000000万个随机数耗时1分48秒：

程序执行了108423毫秒

            二分插入法排序1000000万个已排序的数组耗时42秒：

             二分插入法排序1000000万个倒序的数组耗时3分42秒：

程序执行了224106毫秒

 

           希尔排序：

/**
	 * @Title: shellSort
	 * @Description: TODO(希尔排序)
	 * @param @param is
	 * @return void 返回类型
	 */
	private static void shellSort(int[] is, int[] shell) {
		for (int i = 0; i < shell.length; i++) {
			int d = shell[i];
			for (int j = 0; j < d; j++) {
				for (int k = j + d; k < is.length; k = k + d) {
					int temp = is[k];
					int m;
					for (m = k - d; m >= 0 && is[m] > temp; m = m - d) {
						is[m + d] = is[m];
					}
					is[m + d] = temp;
				}
			}
		}
	}

            希尔排序类似于直接插入排序。他的思想主要是利用了如果在顺序的情况下，直接排序是几乎不耗时的。首先将原数组分成几个不同的数组分别排序，然后合并再次重新细分，直到最后对整个数组进行直接插入排序。但这时候数组基本有序了，所以时间消耗会小很多。

        比如数组｛1，2，3，4｝，首先，希尔排序将数组分成两个子数组，｛1，3｝和｛2，4｝，对两个子数组分别进行直接插入排序后合并然后再次直接插入排序。希尔排序的思想很像分治算法： 把一个大问题分成若干个小问题，利用小问题的结果来对大问题进行计算，从而使大问题得到优化。

       希尔排序1000000万个随机数耗时不到1秒。。。。：

 

程序执行了209毫秒

            希尔排序1000000万个已排序的数组耗时66毫秒：

 

             希尔排序1000000万个倒序的数组耗时82毫秒。

          由以上对比可以发现，对于插入排序来说，在数组几乎排好序的情况下，直接插入排序最好，但现实中这种情况不多，现实中大多是乱序情况，这种情况下希尔排序秒杀其他两种插入排序方法。