分治法：將一個規模為N的問題分解為K個規模較小的子問題，這些子問題相互獨立且與原問題性質相同。求出子問題的解就可得到原問題的解。
遞歸二分法：O(log(2下標)N)

public int recFind(int search, int low, int high) {
        int curIn = (low + high) / 2;
        
        if(arrays[curIn] == search)
            return curIn;
        else if (low > high)
            return mError;
        else {
            if(arrays[curIn] < search)
                return recFind(search, curIn + 1, high);
            else
                return recFind(search, low, curIn - 1);
        }   
    }

漢諾塔：
當只有一個盤子的時候，只需要從將A塔上的一個盤子移到C塔上。

當A塔上有兩個盤子時，先將A塔上的1號盤子（編號從上到下）移動到B塔上，再將A塔上的2號盤子移動的C塔上，最后將B塔上的小盤子移動到C塔上。

當A塔上有3個盤子時，先將A塔上編號1至2的盤子（共2個）移動到B塔上（需借助C塔），然后將A塔上的3號最大的盤子移動到C塔，最后將B塔上的兩個盤子借助A塔移動到C塔上。

當A塔上有n個盤子是，先將A塔上編號1至n-1的盤子（共n-1個）移動到B塔上（借助C塔），然后將A塔上最大的n號盤子移動到C塔上，最后將B塔上的n-1個盤子借助A塔移動到C塔上。
綜上所述，除了只有一個盤子時不需要借助其他塔外，其余情況均一樣（只是事件的復雜程度不一樣）。

public static void hanNouta(int top, char from, char inter, char to) {
        if(top == 1) {
            System.out.println("Disk 1 from " + from + " to " + to);//直接放入目標塔
        } else {
            hanNouta(top - 1,from,to,inter);//借助目標塔將初始塔的n-1個放到借用塔
            
            System.out.println("Disk " + top + " from " + from + " to " + to);//將最后一個盤子放到目標塔
            
            hanNouta(top - 1, inter, from, to);//借用塔n-1個移到目標塔
        }
    }

歸并排序：O(N*logN)

歸并的順序是這樣的：先將初始數組分為兩部分，先歸并低位段，再歸并高位段。對低位段與高位段繼續分解，低位段分解為更細分的一對低位段與高位段，高位段同樣分解為更細分的一對低位段與高位段，依次類推。
上例中，第一步，歸并的是6與2，第二步歸并的是7和4，第三部歸并的是前兩步歸并好的子段[2,6]與[4,7]。至此，數組的左半部分（低位段）歸并完畢，然后歸并右半部分（高位段）。
所以第四步歸并的是8與1，第四部歸并的是5與3，第五步歸并的是前兩步歸并好的字段[1,8]與[3,5]。至此，數組的右半部分歸并完畢。
最后一步就是歸并數組的左半部分[2,4,6,7]與右半部分[1,3,5,8]。
歸并排序結束。

public void merge(int[] data, int low,int mid, int hight){
        int j = 0;
        int lowBegin = low;//低位段的起始下標
        int lowEnd = mid; //低位段的結束下標 
        int hightBegin = mid + 1;//高位段的起始下標
        int hightEnd = hight;//高位段的結束下標
        int n = hight - low + 1; //歸并的元素總數
        
        while(lowBegin<=lowEnd && hightBegin<=hightEnd){
            if(arrays[lowBegin]<arrays[hightBegin]){
                data[j++] = arrays[lowBegin++];
            }else{
                data[j++] = arrays[hightBegin++];
            }
        }
        // 若第一段序列還沒掃描完，將其全部復制到合并序列
        while(lowBegin<lowEnd){
            data[j++] = arrays[lowBegin++];
        }
        // 若第二段序列還沒掃描完，將其全部復制到合并序列
        while(hightBegin<hightEnd){
            data[j++] = arrays[hightBegin++];
        }
        
        for(j=0; j<n; j++){//將歸并好的元素復制到array中
            arrays[low] = data[j];
        }
    }
    
    public void recMergeSort(int[] arrays,int low, int high) {
        if(low == high)
            return;
        else {
            int mid = (low + high)/2;
            recMergeSort(arrays, low, mid);//對低位段歸并排序
            recMergeSort(arrays, mid + 1, high);//對高位段歸并排序  
            merge(arrays, low, mid + 1, high);
        }
    }

鏈接：http://blog.csdn.net/u012152619/article/details/47345107