【算法导论】插入排序

没办法就是这么没原则，又开了个坑。每天看点书，不管什么书。

1. 需求：

　　输入：n个数的一个序列（a1, a2,  a3……an）

　　输出: 输出序列的一个排列（a1', a2', a3' ……an'）,满足a1' <=  a2' <= a3' ……<= an'

2. 图示：

　　

3. 伪代码 

INSERTION-SORT(A)

for j=2 to A.length
    key = A[j]
    i = j-1
    //把A[j]插入到有序数组 A[1...j-1].
    while i > 0 and A[i] > key
        A[i+1] = A[i]
        i = i -1
    A[i + 1] = key

4. 理解

　　算法导论不愧是本好书啊，看这伪代码的注释多精髓，

　　把 A[j] 插入到有序数组 A[1...j-1]

　　j是从2开始的，也就是说我们第一次就是做两个数的排序，这样就是比较A1 和 A2.，这个就容易了。这样得到A的前两个数A1 A2就是有序的

　　当J = 3的时候，我们要做的就是在  * A1 * A2 * 三个星号中找到A3的位置（因为A1 <= A2 已经确定了），根据就近原则，我们先用A3跟A2比，如果比A3 比 A2小，就再跟A1比（如果A3比A2大，那肯定就比A1大了），在跟，然后得到一个新的有序序列A1 A2 A3

　　当J = 4的时候   我们要做的就是在  * A1 * A2 *  A3  * 四个个星号中找到A4的位置（因为A1 <= A2 <= A3 已经确定了），根据就近原则，先跟A3比，然后A2， A1， 然后得到一个新的有序序列A1 A2 A3 A4

　　以此类推

5.代码。因为伪代码的数组下标是从1开始的，所以一些范围判定要改一下

java　　

//java
void insertionSort(int[] A) {
        for(int j = 1, len =A.length; j < len; j++) {
            int key = A[j];
            int i = j-1;
            while(i > -1 && A[i] > key) {
                A[i+1] = A[i];
                i = i-1;
            }
            A[i+1] = key;
        }
        return A;
}
//    input: 5 4 2 9 4 12 6 8 1 3 35
//    output: 1 2 3 4 4 5 6 8 9 12 35

C

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

python

def insertion_sort(arr):
    le = len(arr)
    for i in range(1, le):
        key = arr[i]
        j = i - 1

        while j > -1 and arr[j] > key:
            arr[j+1] = arr[j]
            j -= 1

        arr[j+1] = key

6.  作业 题目我就不抄了，算法导论第三版

2.1-1 插入排序过程

31，   41，  59，   26，   41，   58

31，   41，  59，   26，   41，   58

31，   41，  59，   26，   41，   58

31，   41，  26，   59，   41，   58

31，   26，  41，   59，   41，   58

26，   31，  41，   59，   41，   58

26，   31，  41，   41，   59，   58

26，   31，  41，   41，   58      59

2.1-2：非升序排序伪代码

for i=2 to A.length
    j = i - 1
    key = A[i]
    
    while j > 0 and A[j] < key
        A[j+1] = key
        j = j-1
    A[j+1] = key

2.1-3

for i = 1 to A.length
    if v == A[i] 
        return i
return NIL

2-1-4

　　输入：两个存储二进制整数的 n 元序列 A =（a1, a2, a3, ……an）和 B = (b1, b2, b3……bn), a1......an, b1.......bn只能为1或0

　　输出：一个存储二进制整数的 n+1 元序列 C。C存储的二进制整数为A和B之和

flag =  0
for i = A.length to 1
     sum = A[i] + B[i] + flag
     C[i+1] = sum % 2
     flag = sum / 2
C[1] = flag

这个伪代码也是根据介绍伪代码的标准瞎写