第二章 算法基础

　　本章首先讲了插入排序算法， 然后分析了插入排序算法的时间复杂性，引出了分治法的设计思想，分析了分治算法。

　　1. 插入排序　　

　　插入排序采用了增量算法：在排序子数组A[1...j-1]后，将单个元素A[j]插入到子数组的适当位置，产生排序好的子数组A[1....j]。

　　

package sort;

import util.RandomArray;

public class Insert {
    public static void insertSort(int[] array) {
        // 插入排序
        for (int i = 1; i < array.length; i++) {
            int key = array[i];
            // Insert array[i] into the sorted sequence array[0....i-1]
            int j = i - 1;
            while (j >= 0 && array[j] > key) {
                array[j + 1] = array[j];
                j--;
            }
            array[j + 1] = key;
        }
    }

    public static void main(String arg[]) {
        RandomArray randomArray = new RandomArray(10);

        // 排序前，先把内容打印出来
        randomArray.display();

        insertSort(randomArray.value);

        // 排序后，先把内容打印出来
        randomArray.display();

    }
}

　　事先定义了一个随机数组的类，方便接下来的排序算法。

　　

package util;


public class RandomArray {
    public int[] value;
    
    public RandomArray(int size) {
        value = new int[size];
        for (int i = 0; i < size; i++) {
            value[i] = (int)(Math.random()*100) - 50;
        }
    }
    
    public void display() {
        for (int i = 0; i < value.length; i++) {
            System.out.print(value[i] + " ");
        }
        System.out.println();
    }
}

　　插入排序算法的最好情况是O(n)，最坏的情况是O（n^2）。

　　2. 归并排序

　　许多有用的算法在结构上是递归的：为了解决一个给定的问题，算法一次或者多次的递归调用自身一解决紧密相关的若干子问题。这些算法典型地遵循分治法的思想：将原问题分解为几个规模较小但类似于原问题的子问题，递归地求解这些子问题，然后再合并这些子问题的解来建立原问题的解。

　　

package sort;

import util.RandomArray;

public class Merge {

    public static void mergeSort(int[] array) {
        sort(array, 0, array.length - 1);
    }

    public static void sort(int[] array, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            sort(array, left, mid);
            sort(array, mid + 1, right);
            merge(array, left, mid, right);
        }
    }

    public static void merge(int[] array, int left, int mid, int right) {
        int n1 = mid - left + 1;
        int[] L = new int[n1 + 1];
        
        int n2 = right - mid;
        int[] R = new int[n2 + 1];
        
        for (int i = 0; i < n1; i++) {
            L[i] = array[left + i];
        }
        L[n1] = Integer.MAX_VALUE;
        
        for (int j = 0; j < n2; j++) {
            R[j] = array[mid + j + 1];
        }
        R[n2] = Integer.MAX_VALUE;
        
        int i = 0;
        int j = 0;
        for (int k = left; k <= right; k++) {
            if (L[i] <= R[j]) {
                array[k] = L[i];
                i++;
            } else {
                array[k] = R[j];
                j++;
            }
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        RandomArray randomArray = new RandomArray(1000000);

        // 排序前，先把内容打印出来
        // randomArray.display();

        mergeSort(randomArray.value);

        // 排序后，先把内容打印出来
        // randomArray.display();
        System.out.println("ends");
    }

}

 　　上面的merge方法使用了哨兵的方式，也可以不适用哨兵，代码如下：

　　

//不采用哨兵
    public static void merge(int[] array, int left, int mid, int right) {
        int n1 = mid - left + 1;
        int[] L = new int[n1];
        
        int n2 = right - mid;
        int[] R = new int[n2];
        
        for (int i = 0; i < n1; i++) {
            L[i] = array[left + i];
        }
        
        for (int j = 0; j < n2; j++) {
            R[j] = array[mid + j + 1];
        }
        
        int i = 0;
        int j = 0;
        for (int k = left; k <= right; k++) {
            if(i == n1) {
                System.arraycopy(R, j, array, k, right-k+1);
                break;
            }
            
            if(j == n2) {
                System.arraycopy(L, i, array, k, right-k+1);
                break;
            }
            
            if (L[i] <= R[j]) {
                array[k] = L[i];
                i++;
            } else {
                array[k] = R[j];
                j++;
            }
        }
    }

　　归并排序的算法效率为O（n*lgn），但在合并中分配了左右两个子数组，牺牲了一定的空间。