最快排序和搜尋演算法的最簡代碼實現_轉

標籤：否則   length   去除   起點   https   描述   引擎   快排序   flex   

轉自： 4053853

前言

         演算法的核心問題是排序和搜尋。這2個領域應用最廣，研究也最透。本文我將講解排序和搜尋領域最高效的兩個演算法：快速排序演算法和二分搜尋演算法。

         教科書和很多實現庫給出的這兩個演算法的代碼非常複雜，很難理解，本文中我給出的代碼是最簡單的實現代碼，易於理解，效率也很高。

緣起

         剛才有人問我怎樣實現快速排序，我在5分鐘之內寫了一個快速排序的Java代碼出來，不知道他們有沒有理解。

因此，我想到要寫作這篇文章。介紹一下快速排序演算法和二分搜尋演算法的最簡實現。

         我的二分搜尋演算法是在我用Flex開發工作流程編輯器時實現的。當時的需求是在2個圖形之間畫出連接線，要求根據滑鼠操作來繪製，並且線段的起點和終點都是在圖形的外框上。

         上面的描述可能比較抽象，這麼說吧，原來我實現的GUI效果是，2個方框，使用滑鼠把它們串連起來，我繪製的線是滑鼠點下和釋放這2個端點串連起來的線段。但是，這樣的線段比較醜，客戶要求線段的兩頭應該在2個方框的邊框上。

         怎麼解決這個問題呢？我把線段看做是排序後的點的集合，然後就可以使用二分搜尋演算法搜尋到線段和邊框的交點，然後把它們繪製出來。

         當時的二分搜尋演算法是用ActionScript3寫的，現在我把它改成Java了。

快速排序演算法和二分搜尋演算法

         演算法主要分為排序演算法、搜尋演算法、圖演算法。圖演算法我用得不多，沒有發言權，本文就不說了。

         排序演算法中最快的是快速排序演算法，搜尋演算法中最快的是二分搜尋演算法。我也最喜歡這2個演算法。

         因為，它們是使用遞迴實現的，代碼簡潔清晰，效率又非常高。

         根據我的理解，演算法的本質就是數學。根據輸入和設定的目標，採用有限的步驟實現輸出。通常，使用電腦實現的演算法，都會用到迴圈，這樣才能發揮電腦高速運算的優勢。

         迴圈和遞迴是等效的，這已經被科學家所證明。數學上沒有迴圈，只有遞迴的概念，因此使用遞迴代替迴圈表示演算法有很多好處：

1，  遞迴的代碼要比迴圈簡潔很多，也優雅很多。

2，  遞迴的代碼可以用數學方式建模，可以從數學角度驗證其正確性。

很多函數式語言甚至沒有迴圈的概念和關鍵字，強迫你使用遞迴來實現迴圈。如，ErLang。

遞迴也有一些缺點，遞迴使用棧來儲存函數地址和參數、傳回值，而棧是有一定大小的，過多的遞迴調用可能會造成棧溢出。

但是，遞迴演算法會容易轉變為迴圈。我更欣賞遞迴的簡潔，除非真的出現棧溢出的問題，我是不會使用迴圈的。

二分搜尋演算法理論：

         二分搜尋演算法用於針對已排序的集合進行搜尋。

它的原理是：

1，  找到排序數組的中間元素，如果它匹配目標值，那麼就返回它在數組中的索引。

2，  如果沒有找到，那麼判斷中間值比目標值大還是小，

如果中間值比目標值大，那麼就對第一個元素到middle-1的元素遞迴這個過程。

如果中間值比目標值小，那麼就對middle+1到最後一個元素。

3，  如果結束的索引小於開始的索引，返回-1，表示沒有找到。

4，  如果子集合有2個元素，那麼各自比較。因為Java的整數除法會捨棄小數，如果數組只有2個元素，那麼middle值一直都是第一個元素。

經過上述的遞迴過程，最終將返回匹配元素的索引，或者是-1，表示找不到。

 

二分搜尋演算法之所以速度快，是因為它每次可以把數組切分成兩半，每次遞迴調用都能去除一半資料，而不用匹配每一個資料。

 

代碼：

         下面是代碼，邏輯清楚，代碼簡單。

/**

     * by 沈東良/良少     http://blog.csdn.net/shendl/

     * @param array

     * @param start

     * @param end   這是最後一個元素的索引，第一次調用應該是array.length-1

     * @param value

     * @return

     */

    public static int binarySearch(int[] array,int start,int end,int value){

       int middle=(start+end)/2;

       if(end<start){

           return -1;

       }

       if(end==(start+1)){

           if(array[start]==value){

              return start;

           }else if(array[end]==value){

              return end;

           }

          

       }else if(array[middle]==value){

           return middle;

       }else if(value>array[middle]){

           return binarySearch(array,middle+1,end,value);

       }else if(value<array[middle]){

           return binarySearch(array,start,middle-1,value);

       }

       return -1;

   

    }

 

         上述代碼稍加改變，就可以排序任意類型。如使用泛型，然後加上對Comparable介面的實現，即可。

 

快速排序演算法

         二分搜尋演算法確實非常快，但是它只能用於已排序數組。如果數組未排序呢，該怎麼辦呢？簡單，先用快速排序演算法進行排序，然後再用二分搜尋進行搜尋。

         先排序再搜尋，要比匹配每一個元素快得多。搜尋引擎，資料庫索引也都使用了對資料集合的排序技術，這樣搜尋資料才會快速。

理論：

         最慢，也是最容易想到的排序演算法是插入排序演算法：

1，  遍曆數組，找出最小的元素，把它放到第一個元素。

2，  迴圈尋找未排序的數組，直到整個數組排序。

這需要2個嵌套的迴圈，意味著它的效率是O(n^2);

之所以插入排序的效率如此之地，是因為要找出整個數組中最小的資料，需要遍曆整個數組的元素。

而插入排序聰明就聰明在它不尋找整個數組最小、次小…的元素，而是每次僅僅把小於某個元素的值移到一邊，通過迭代最終自動實現排序。這就大大節約了排序所需的計算步驟。

 

         快速排序演算法的理論：

1，  如果S中的元素個數是0或者1，那麼返回。

2，  選取S中的任一元素v，稱為中心點。

3，  將S集合中的元素分為2個部分：L={小於pivot 的元素+ pivot }和R={大於或者等於pivot的元素}。

4，  返回L和R。

我們使用Java使用的是就地排序的方式，因此不需要傳回值。

因為Java是一種可以修改變數的語言，用函數式語言的術語來說，就是有“副作用”。我們利用這個副作用直接修改作為參數的Array，不需要傳回值。

 

代碼：

/** by 沈東良/良少     http://blog.csdn.net/shendl/

     * 快速排序，有副作用   從小到大

     * @param array

     * @param start

     * @param end這是最後一個元素的索引，第一次調用應該是array.length-1

     */

    public static void quickSort(int[] array,int start,int end){

       //有可能造成start>end   因為遞迴調用時j+1，可能引起j比end還大1。  另外如果數組是空的，或者輸入錯誤也會出現這種情況

       if(end<=start){

           return;          

       }else {

           //取中間元素為中心點，然後移到最右邊

           int sign=(start+end)/2;

           int tmp=array[end];

           array[end]=array[sign];

           array[sign]=tmp;

           int j=start;

           for(int i=start;i<=end-1;i++){ 

              //小於的元素和標記互換，等於的不能互換，否則會形成死迴圈

              if(array[i]<array[end])  {                

                   tmp=array[i];

                   array[i]=array[j];

                   array[j]=tmp;

                   j=j+1;

              }         

           }

           //把標記元素和第一個>=它的元素位置互換，這樣數組就分成2個部分，一個部分比中心值小，一個部分比中心值大。

           tmp=array[j];

           array[j]=array[end];

           array[end]=tmp;

           quickSort(array,start,j);

           quickSort(array,j+1,end);

       }

    }

 

         Java的Arrays類也使用快速排序演算法進行排序。但它的代碼寫得像天書一樣。

 

         提高快速排序演算法執行效率的主要方法是對中心點進行檢測，希望選中的中心點有更大的機率是整個數組的中值。

         我的實現中簡單的選擇數組中間的值作為中心點，一般來說這樣的選擇效率還是不錯的。

 

         注意上面的一項實現技術，我們使用把中心資料元素移到數組最後的方式實現了數組的就地比較。這是比較常用的技術，把資料移到數組的最前面或者最後面，方便比較資料。

 

         另外，我的Java快速排序代碼使用了“副作用”，而在純函數式語言，如Haskell,ErLang中是沒有“副作用”的，也就是說變數不可以重新賦值。此時就需要傳回值，每次都建立新的子數組。但函數式語言的數組處理功能很強，也會做很多效能最佳化，因此函數式語言實現快速排序代碼更加簡單，沒有“副作用”，也更加數學化。

 

JDK使用二分搜尋和快速排序演算法實現搜尋和排序，足見上述兩個演算法的效能優勢。

最快排序和搜尋演算法的最簡代碼實現_轉