分治演算法

4) 該問題所分解出的各個子問題是相互獨立的，即子問題之間不包含公共的子子問題。

八，典型分治法案例解析

1,快速排序

快排是C.R.A.Hoare於1962年提出的一種劃分交換排序。它採用了一種分治的策略，該方法的基本思想是：
1)．先從數列末尾取出一個數作為基準元。
2)．分割槽過程，將比這個數大的數全放到它的右邊，小於或等於它的數全放到它的左邊。
3)．再對左右區間重複第二步，直到各區間只有一個數。

1. //手動快速默寫快排：先劃界，再分治....  
2. int quickPartion(int *arr, int low, int high)  
3. {  
4.     int pos = rand() % (high - low + 1) + low;  
5.     swap(arr, pos, high);//將末尾的元素隨機化,防止極端情況  
6.     int key = arr[high];//總是將末尾元素選為關鍵化界元
7.     int i = low - 1;//總是記錄比key小的元素最前面的位置
8.     for (int j = low; j <= high - 1; j++)  
9.     {  
10.         if (arr[j] <= key)  
11.             swap(arr, ++i, j);  
12.     }  
13.     swap(arr, ++i, high);  
14.     return i;//返回“中間位置”
15. }  
16. void QuickSort(int *arr, int low, int high)  
17. {  
18.     if (low < high)  
19.     {  
20.         int mid = quickPartion(arr, low, high);  
21.         QuickSort(arr, low, mid - 1);  
22.         QuickSort(arr, mid + 1, high);  
23.     }  
24. }  

2，歸併排序
歸併排序是把序列遞迴地分成短序列，遞迴出口是短序列只有1個元素(認為直接有序)或者2個序列(1次比較和交換),然後把各個有序的段序列合併成一個有序的長序列，不斷合併直到原序列全部排好序。可以發現，在1個或2個元素時，1個元素不會交換，2個元素如果大小相等也沒有人故意交換，這不會破壞穩定性。那麼，在短的有序序列合併的過程中，穩定是是否受到破壞？沒有，合併過程中我們可以保證如果兩個當前元素相等時，我們把處在前面的序列的元素儲存在結果序列的前面，這樣就保證了穩定性。所以，歸併排序也是穩定的排序演算法。

核心函式：

1. //分治法的合併函式  
2. //arr[low...mid]與arr[mid+1...high]相合並
3. void Merge(int *arr, int low, int mid, int high)  
4. {  
5.     int leftlen = mid - low + 1;//arr[low...mid]的長度
6.     int rightlen = high - mid;//arr[mid+1...high]的長度
7.     int *L = newint[leftlen + 1];//每次歸併時都在動態申請記憶體，這裡可以優化
8.     int *R = newint[rightlen + 1];  
9.     L[leftlen] = INT_MAX;//末尾均是哨兵元素    
10.     R[rightlen] = INT_MAX;  
11.     //賦值，準備有序放入arr[low.....high]
12.     int i = 0;  
13.     for (; i < leftlen; i++)  
14.         L[i] = arr[low + i];  
15.     int j = 0;  
16.     for (; j < rightlen; j++)  
17.         R[j] = arr[mid + j + 1];  
18.     //有序放入arr[low.....high]
19.     i = 0; j = 0;  
20.     for (int k = low; k <= high; k++)  
21.     {  
22.         if (L[i] <= R[j])//誰更小，誰就放入arr[k]中
23.             arr[k] = L[i++];  
24.         else
25.             arr[k] = R[j++];  
26.     }  
27.     delete[] L; L = NULL;  
28.     delete[] R; R = NULL;  
29. }  
30. //合併排序法（分治法）  
31. void MergeSort(int *arr, int low, int high)  
32. {  
33.     if (low < high)  
34.     {  
35.         int mid = (low + high) / 2;  
36.         MergeSort(arr, low, mid);  
37.         MergeSort(arr, mid + 1, high);  
38.         Merge(arr, low, mid, high);  
39.     }  
40. }  

九，Leetcode例項

題目：

在一個未排序的陣列中找到第k大的元素，注意此言的第k大就是排序後的第k大的數，
注意：給定k總是安全有效的。

分析：

總是將要劃界的陣列段末尾的元素為劃界元，將比其小的數交換至前，比其大的數交換至後，最後將劃界元放在“中間位置”（左邊小，右邊大）。劃界將陣列分解成兩個子陣列（可能為空）。

設陣列下表從low開始，至high結束。
1、 總是取要劃界的陣列末尾元素為劃界元x，開始劃界：

a) 用j從low遍歷到high-1（最後一個暫不處理），i=low-1，如果nums[j]比x小就將nums[++i]與nums[j]交換位置

b) 遍歷完後再次將nums[i+1]與nums[high]交換位置（處理最後一個元素）;

c) 返回劃界元的位置i+1，下文稱其為midpos

這時的midpos位置的元素，此時就是整個陣列中第N-midpos大的元素，我們所要做的就像二分法一樣找到K=N-midpos的“中間位置”，即midpos=N-K

2、 如果midpos==n-k，那麼返回該值，這就是第k大的數。
3、 如果midpos>n-k，那麼第k大的數在左半陣列
4、 如果midpos<n-k，那麼第k大的數在右半陣列

//思路首先：  
//快排劃界，如果劃界過程中當前劃界元的中間位置就是k則找到了  
//time,o(n*lg(k)),space,o(1)  
class Solution {  
public:  
    //對陣列vec，low到high的元素進行劃界，並獲取vec[high]的“中間位置”  
    int quickPartion(vector<int> &vec, int low,int high)  
    {    
        int x = vec[high];  
        int i = low - 1;  
        for (int j = low; j <= high - 1; j++)  
        {  
            if (vec[j] <= x)//小於x的劃到左邊  
                swap(vec,++i,j);  
        }  
        swap(vec,++i,high);//找到劃界元的位置  
        return i;//返回位置  
    }   
    //交換陣列元素i和j的位置  
    void swap(vector<int>& nums, int i, int j){    
        int temp = nums[i];    
        nums[i]=nums[j];    
        nums[j]=temp;    
    }   
    int getQuickSortK(vector<int> &vec, int low,int high, int k)    
    {    
        if(low >= high) return vec[low];  
        int  midpos = quickPartion(vec, low,high);   //對原陣列vec[low]到vec[high]的元素進行劃界    
        if (midpos == vec.size() - k)      //如果midpos==n-k，那麼返回該值，這就是第k大的數    
            return vec[midpos];  
        else if (midpos < vec.size() - k)  //如果midpos<n-k，那麼第k大的數在右半陣列   
            return getQuickSortK(vec, midpos+1, high, k);  
        else                               //如果midpos>n-k，那麼第k大的數在左半陣列   
            return getQuickSortK(vec, low, midpos-1, k);  
    }   
    int findKthLargest(vector<int>& nums, int k) {  
        return getQuickSortK(nums,0,nums.size()-1,k);  
    }  
};  

注：本博文為EbowTang原創，後續可能繼續更新本文。如果轉載，請務必複製本條資訊！

原文地址：http://blog.csdn.net/ebowtang/article/details/51638278

原作者部落格：http://blog.csdn.net/ebowtang

本部落格LeetCode題解索引：http://blog.csdn.net/ebowtang/article/details/50668895