插入排序

插入排序 

通常人们在摸牌的时候，每摸到一张牌，都会将它插入到已经有序的牌中的适当位置。在计算机的实现中，为了给要插入的元素腾出空间，我们需要将其余所有元素在插入之前都向右移动一位，这种算法叫插入排序，与选择排序一样，当前索引左边的所有元素都是有序的，但它们最终的位置还不确定，为了给更小的元素腾出空间，它们可能还会被移动。但是当程序遍历完整个数组时，数组的排序就完成了。

插入排序的时间复杂度分析：在最坏的情况下，数组完全逆序，在插入第二个元素前，需要遍历第一个元素，在插入第三个元素时，需要遍历第一和第二个元素……在插入第N个元素前，需要遍历第一到第N-1个元素，1+2+……+(N-1)=N²/2，所以，最差的时间复杂度为O(n²)，而最好的情况，是整个数组都有序，在插入第二个元素时只检查第一个元素，在插入第三个元素时只检查第二个元素……在插入第N个元素时只检查第N-1个元素，因此，最好的时间复杂度为O(n)。

代码1-1为插入排序的C语言实现

#include <stdio.h>

void insertion_sort( int arr[], int len );


void insertion_sort( int arr[], int len )
{
	int i = 0, j = 0, temp = 0;
	for ( i = 1; i < len; i++ )
	{
		for ( j = i; j > 0 && arr[j] < arr[j - 1]; j-- )
		{
			temp		= arr[j];
			arr[j]		= arr[j - 1];
			arr[j - 1]	= temp;
		}
	}
}


void main()
{
	int	i	= 0;
	int	arr[]	= { 1, 10, -5, 9, 8, 7, 3 };
	int	len	= sizeof(arr) / sizeof(arr[0]);
	printf( "待排序数组:" );
	for ( i = 0; i < len; i++ )
	{
		printf( "%d ", arr[i] );
	}
	printf( "
" );
	insertion_sort( arr, len );
	printf( "排序后数组:" );
	for ( i = 0; i < len; i++ )
	{
		printf( "%d ", arr[i] );
	}
}

　　

代码1-2为插入排序的Java实现

import java.util.Arrays;

public class Insertion {

	public static void insertionSort(int... arr) {
		for (int i = 1; i < arr.length; i++) {
			for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
				int temp = arr[j];
				arr[j] = arr[j - 1];
				arr[j - 1] = temp;
			}
		}
	}

	public static void main(String[] args) {
		int[] arr = { 1, 10, -5, 9, 8, 7, 3 };
		System.out.print("待排序数组:" + Arrays.toString(arr));
		System.out.println();
		insertionSort(arr);
		System.out.println("排序后数组:" + Arrays.toString(arr));
	}

}

　　

代码1-3为插入排序的Python实现

# coding:utf-8
def insertion_sort(arr):
    for i in range(1, len(arr)):
        j = i
        while j > 0 and arr[j] < arr[j - 1]:
            temp = arr[j]
            arr[j] = arr[j - 1]
            arr[j - 1] = temp
            j -= 1


arr = [1, 10, -5, 9, 8, 7, 3]
print "待排序数组:", arr
insertion_sort(arr)
print "排序后数组", arr

　

代码1-3为插入排序的Scala实现

import java.util.Arrays

object Insertion {

  def insertionSort(comparator: (Int, Int) => Boolean)(lists: List[Int]): List[Int] = {
    def insert(item: Int, items: List[Int]): List[Int] = items match {
      case List()  => List(item)
      case x :: xs => if (comparator(item, x)) x :: insert(item, xs) else item :: items
    }
    lists match {
      case List()  => lists
      case x :: xs => insert(x, insertionSort(comparator)(xs))
    }
  }

  def main(args: Array[String]): Unit = {
    val list = List(1, 10, -5, 9, 8, 7, 3)
    println("待排序数组:" + Arrays.toString(list.toArray))
    val sortList = insertionSort(_ > _)(list)
    println("排序数组:" + Arrays.toString(sortList.toArray))
  }

}