常用排序算法（插入排序）

插入排序使用的是增量（incremental）方法；在排好子数组A[1..j-1]后，将A[j]插入，形成排好序的子数组A[1..j]。
更多信息请参考：http://baike.baidu.com/view/396887.htm

C语言代码：

#include <stdlib.h>
#include <stdio.h>
#include <memory.h>
#include <time.h>

void init(int *array, int count)
{
    int n = 0;
    srand((unsigned int)time(NULL));

    for (n=0; n<count; n++)
    {
        array[n] = rand()%100 + 1;
    }
}

void output(int *array, int count)
{
    int n = 0;
    for (n=0; n<count; n++)
    {
        printf("%5d", array[n]);
    }

    printf("\n");
}

void insertsort(int* array, int count, int type)   
{
    int i = 0;
    int j = 0;
    int temp = 0;;  
    if (type == 0)   
    {   
        //正排序，从小排到大  
        //比较的轮数  
        for (i = 1; i<count; i++)   
        {  
            //保证前i个数排好序  
            temp=array[i];  
            j = i-1;  
            while(j>=0&&array[j]>temp)  
            {  
                array[j+1]=array[j];  
                j--;  
            }  

            array[j+1]=temp;  
        }  
    }  
    else
    {   
        //倒排序，从大排到小  
        //比较的轮数  
        for (i = 1; i<count; i++)   
        {  
            //保证前i个数排好序  
            temp=array[i];  
            j = i-1;  
            while(j>=0&&array[j]<temp)  
            {  
                array[j+1]=array[j];  
                j--;  
            }  

            array[j+1]=temp;  
        }  
    }
}

int main()
{
    const int count = 10;
    int array[count];

    memset(array, 0, sizeof(int)*count);

    init(array, count);
    
    printf("data before sort:      ");
    output(array, count);

    insertsort(array, count, 0);  // 正排序，从小排到大
    printf("data after sort(asc):  ");
    output(array, count);

    insertsort(array, count, 1);  // 倒排序，从大排到小
    printf("data after sort(desc): ");
    output(array, count);
    
    return 0;
}

运行结果如下：
data before sort:         71   68   58   93   32   80  100   73   10   18
data after sort(asc):     10   18   32   58   68   71   73   80   93  100
data after sort(desc):   100   93   80   73   71   68   58   32   18   10


Java代码：

import java.util.Random;

/**
* 插入排序
* 方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。     
* 性能：比较次数O(n^2),n^2/4
* 比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。
*/

public class Sort 
{
	/*
	 * 输出数组中的数据
	 */
    public static void OutputArray(int[] array) 
    {
        for (int data : array) 
        {
            System.out.print(data + "\t");
        }
        
        System.out.println();
    }
    
    /*
     * 生成需要排序的数组
     */
    public static int[] createArray(int count) 
    {
        int array[] = new int[count];
        Random r = new Random();
        
        for (int i = 0; i < count; i++) 
        {
            array[i] = r.nextInt(100);
        }
        
        System.out.println("");
        System.out.print("data before sort:\t");
        
        OutputArray(array);
        
        return array;
    }
    
    /**
    * 插入排序
    */
    public static void insertSort(int[] array, String sortType) 
    {
        int insertValue;
        if (sortType.equals("asc")) 
        {   //正排序，从小排到大
            //比较的轮数
            for (int i = 1; i <array.length; i++) 
            {
                //保证前i个数排好序
                insertValue=array[i];
                int index=i-1;
                while(index>=0&&array[index]>insertValue)
                {
                    array[index+1]=array[index];
                    index--;
                }
                
                array[index+1]=insertValue;
            }
        }
        else if (sortType.equals("desc")) 
        {   //倒排序，从大排到小
            //比较的轮数
            for (int i = 1; i <array.length; i++) 
            {
                //保证前i个数排好序
                insertValue=array[i];
                int index=i-1;
                while(index>=0&&array[index]<insertValue)
                {
                    array[index+1]=array[index];
                    index--;
                }
                
                array[index+1]=insertValue;
            }
        } 
        else
        {
            System.out.println("您输入的排序类型错误！");
        }
    }
    
    public static void main(String[] args) 
    {
        int[] arr1=createArray(10);
        
        System.out.print("data after sort(asc):\t");
        insertSort(arr1, "asc");
        OutputArray(arr1);
        
        System.out.print("data after sort(desc):\t");
        insertSort(arr1, "desc");
        OutputArray(arr1);
    }
}

运行结果如下：
data before sort:    33    99    96    91    85    97    85    82    58    86    
data after sort(asc):    33    58    82    85    85    86    91    96    97    99    
data after sort(desc):    99    97    96    91    86    85    85    82    58    33