Java实现经典排序算法----3、插入排序(内含JAVA和JS代码)

3、插入排序（Insertion Sort）

      插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

• 从第一个元素开始，该元素可以认为已经被排序；
• 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 如果该元素（已排序）大于新元素，将该元素移到下一位置；
• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 将新元素插入到该位置后；
• 重复步骤2~5。

3.2 动图演示

插入排序过程

3.3 代码实现

3.3.1JAVA版

//Java实现插入排序
public class InsertSort {
        //基础版
	public int[] insertSort(int[] arr){

		for(int i=1; i<arr.length; i++){
			for(int j=i; j>0; j--){
				if(arr[j]<arr[j-1]){
					int temp = arr[j-1];
					arr[j-1] = arr[j];
					arr[j] = temp;
				}
			}
		}
		return arr;
	}
        //进阶版
	public int[] insertSort2(int[] arr){

		for(int i=1; i<arr.length; i++){
			int temp = arr[i];//保存每次需要插入的那个数
			int j;
			for(j=i; j>0&&arr[j-1]>temp; j--){//这个较上面有一定的优化
			   //把大于需要插入的数往后移动。最后不大于temp的数就空出来j
                           arr[j] = arr[j-1];
			}
			arr[j] = temp;//将需要插入的数放入这个位置
		}
		return arr;
	}

	public static void main(String[] args) {
		InsertSort s = new InsertSort();
		int[] arr = { 11, 3, 29, 49, 30, 7, 50, 63, 46};
		System.out.println("未排序的数组：" + Arrays.toString(arr));
//		s.insertSort1(arr);
//		s.insertSort2(arr);
		s.insertSort3(arr);
		System.out.println("排序后的数组：" + Arrays.toString(arr));
	}
}

3.3.2JS版

       function binaryInsertionSort(array) {
            console.time('二分插入排序耗时：');
            for (var i = 1; i < array.length; i++) {
                var key = array[i], left = 0, right = i - 1;
                while (left <= right) {
                    var middle = parseInt((left + right) / 2);
                    if (key < array[middle]) {
                        right = middle - 1;
                    } else {
                        left = middle + 1;
                    }
                }
                for (var j = i - 1; j >= left; j--) {
                    array[j + 1] = array[j];
                }
                array[left] = key;
            }
            console.timeEnd('二分插入排序耗时：');
            return array;
        }

        function insertionSort2(array) {
            console.time('插入排序耗时2：');
            for(var i=1; i<array.length; i++){
                for(var j=i; j>0; j--){
                    if(array[j]<array[j-1]){
                        var temp = array[j-1];
                        array[j-1] = array[j];
                        array[j] = temp;
                    }
                }
            }
            console.timeEnd('插入排序耗时2：');
            return array;
        }

        function insertionSort3(array) {
            console.time('插入排序耗时3：');
            for(var i=1; i<array.length; i++){
                var temp = array[i];//保存每次需要插入的那个数
                for(var j=i; j>0&&array[j-1]>temp; j--){//这个较上面有一定的优化
                    //把大于需要插入的数往后移动。最后不大于temp的数就空出来j
                    array[j] = array[j-1];
                }
                array[j] = temp;//将需要插入的数放入这个位置
            }
            console.timeEnd('插入排序耗时3：');
            return array;
        }

        var arr1=[3,44,38,5,47,15,36,26,27,2,46];
        console.log(binaryInsertionSort(arr1));
        var arr2=[3,44,38,5,47,15,36,26,27,2,46];
        console.log(insertionSort2(arr2));
        var arr3=[3,44,38,5,47,15,36,26,27,2,46];
        console.log(insertionSort3(arr3));

3.4 算法分析

      插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。