2. 程式人生 > >基礎演算法--排序：之快速排序

基礎演算法--排序：之快速排序

阿新 • • 發佈：2018-11-12

與簡單排序不同，快序排序所需的比較次數較少，是內部排序中速度較快的一種排序方法。

 

 演算法思想： 分-------------- 將待排序集合劃分為2部分 （一部分小於準則值，一部分大於等於準則值）

                         這個分的過程是不斷迭代的，直到無法再分為止。

 

 

   

 

 

演算法過程演示：

 

    

   

 

     一趟排序所使用的演算法：

 

示例：

 

      

 

   

示例：

   

   

  

演算法：

    

 

 

    演算法分析：

 

    

 

 

 

 

程式程式碼：

 

形式1：

[cpp] view plaincopy

  1. void QuickSort(int R[], int low,int high)  
  2. {  
  3.     int i,j;  
  4.     int pivot;  
  5.     i=low;  
  6.     j=high;  
  7.     pivot=R[i];  
  8.   
  9.     do   
  10.     {  
  11.         while((R[j]>=pivot)&&(i<j)) j--;  
  12.         if(i<j) R[i++]=R[j];  
  13.   
  14.         while(R[i]<pivot&&(i<j)) i++;  
  15.         if(i<j) R[j--]=R[i];  
  16.   
  17.     } while (i!=j);  
  18.   
  19.     R[i]=pivot;  
  20.   
  21.     if(low<i-1) QuickSort(R,low,i-1);  
  22.     if(high>i+1) QuickSort(R,i+1,high);  
  23.   
  24. }  


形式1---優化1：（如何確定基準值）

 

[cpp] view plaincopy

  1. void QuickSort(int R[], int low,int high)  
  2. {  
  3.     int i,j;  
  4.     int pivot;  
  5.   
  6.     int & iLeft=R[low];  
  7.     int & iRight=R[high];  
  8.     int & iMiddle=R[(low+high)/2];  
  9.   
  10.     //  目的為了使  準則值R[low] 為這三個值的中間值  
  11.   
  12.     int temp;  
  13.   
  14.     if (iLeft>iMiddle)  
  15.     {  
  16.         temp=iMiddle;  
  17.         iMiddle=iLeft;  
  18.         iLeft=temp;  
  19.     }  
  20.   
  21.     if (iRight>iMiddle)  
  22.     {  
  23.         temp=iMiddle;  
  24.         iMiddle=iRight;  
  25.         iRight=temp;  
  26.     }  
  27.   
  28.     if (iLeft<iRight)  
  29.     {  
  30.         temp=iRight;  
  31.         iRight=iLeft;  
  32.         iLeft=iRight;  
  33.     }  
  34.   
  35.     i=low;  
  36.     j=high;  
  37.     pivot=R[i];  
  38.   
  39.     do   
  40.     {  
  41.         while((R[j]>=pivot)&&(i<j)) j--;  
  42.         if(i<j) R[i++]=R[j];  
  43.   
  44.         while(R[i]<pivot&&(i<j)) i++;  
  45.         if(i<j) R[j--]=R[i];  
  46.   
  47.     } while (i!=j);  
  48.   
  49.   
  50.     R[i]=pivot;  
  51.     if(low<i-1) QuickSort(R,low,i-1);  
  52.     if(high>i+1) QuickSort(R,i+1,high);  
  53.   
  54. }  


形式1----優化2 （元素個數小於30時，採用選擇排序）

[cpp] view plaincopy

  1. void QuickSort(int R[], int low,int high)  
  2. {  
  3.     int i,j;  
  4.     int pivot;  
  5.   
  6.     int & iLeft=R[low];  
  7.     int & iRight=R[high];  
  8.     int & iMiddle=R[(low+high)/2];  
  9.   
  10.     //  目的為了使  準則值R[low] 為這三個值的中間值  
  11.   
  12.     int temp;  
  13.   
  14.     if (iLeft>iMiddle)  
  15.     {  
  16.         temp=iMiddle;  
  17.         iMiddle=iLeft;  
  18.         iLeft=temp;  
  19.     }  
  20.   
  21.     if (iRight>iMiddle)  
  22.     {  
  23.         temp=iMiddle;  
  24.         iMiddle=iRight;  
  25.         iRight=temp;  
  26.     }  
  27.   
  28.     if (iLeft<iRight)  
  29.     {  
  30.         temp=iRight;  
  31.         iRight=iLeft;  
  32.         iLeft=iRight;  
  33.     }  
  34.   
  35.     i=low;  
  36.     j=high;  
  37.     pivot=R[i];  
  38.   
  39.     do   
  40.     {  
  41.         while((R[j]>=pivot)&&(i<j)) j--;  
  42.         if(i<j) R[i++]=R[j];  
  43.   
  44.         while(R[i]<pivot&&(i<j)) i++;  
  45.         if(i<j) R[j--]=R[i];  
  46.   
  47.     } while (i!=j);  
  48.   
  49.   
  50.     R[i]=pivot;  
  51.   
  52. /* 
  53.     if(low<i-1) QuickSort(R,low,i-1); 
  54.     if(high>i+1) QuickSort(R,i+1,high); 
  55. */  
  56.   
  57.     if(i-low>30)   
  58.         QuickSort(R,low,i-1);  
  59.     else  
  60.         StraightSelectionSort(R,i-low);  
  61.   
  62.   
  63.     if (high-i>30)  
  64.         QuickSort(R,i+1,high);  
  65.     else  
  66.         StraightSelectionSort(&R[i+1],high-i);  
  67.   
  68. }  


 

形式2:

[cpp] view plaincopy

  1. void QuickSort(int R[], int n)  
  2. {  
  3.     int i,j;  
  4.     int pivot;  
  5.     i=0;  
  6.     j=n-1;  
  7.     pivot=R[i];  
  8.   
  9.     do   
  10.     {  
  11.         while((R[j]>=pivot)&&(i<j)) j--;  
  12.         if(i<j) R[i++]=R[j];  
  13.   
  14.         while(R[i]<pivot&&(i<j)) i++;  
  15.         if(i<j) R[j--]=R[i];  
  16.   
  17.     } while (i!=j);  
  18.   
  19.     R[i]=pivot;  
  20.   
  21.     if(i>1) QuickSort(R,i);  
  22.     if(n-i-1>1) QuickSort(&R[i+1],n-i-1);  
  23.   
  24. }  


形式2---優化1

[cpp] view plaincopy

  1. void QuickSort(int R[], int n)  
  2. {  
  3.     int i,j;  
  4.     int pivot;  
  5.   
  6.   
  7.     int & iLeft=R[0];  
  8.     int & iRight=R[n-1];  
  9.     int & iMiddle=R[(n-1)/2];  
  10.   
  11.     //  目的為了使  準則值R[low] 為這三個值的中間值  
  12.   
  13.     int temp;  
  14.   
  15.     if (iLeft>iMiddle)  
  16.     {  
  17.         temp=iMiddle;  
  18.         iMiddle=iLeft;  
  19.         iLeft=temp;  
  20.     }  
  21.   
  22.     if (iRight>iMiddle)  
  23.     {  
  24.         temp=iMiddle;  
  25.         iMiddle=iRight;  
  26.         iRight=temp;  
  27.     }  
  28.   
  29.     if (iLeft<iRight)  
  30.     {  
  31.         temp=iRight;  
  32.         iRight=iLeft;  
  33.         iLeft=iRight;  
  34.     }  
  35.   
  36.     i=0;  
  37.     j=n-1;  
  38.     pivot=R[i]; //  此時R[0]為 上述三值得中間值  
  39.   
  40.   
  41.   
  42.     do   
  43.     {  
  44.         while((R[j]>=pivot)&&(i<j)) j--;  
  45.         if(i<j) R[i++]=R[j];  
  46.   
  47.         while(R[i]<pivot&&(i<j)) i++;  
  48.         if(i<j) R[j--]=R[i];  
  49.   
  50.     } while (i!=j);  
  51.   
  52.     R[i]=pivot;  
  53.   
  54.     if(i>1) QuickSort(R,i);  
  55.     if(n-i-1>1) QuickSort(&R[i+1],n-i-1);  
  56.   
  57. }  


 

形式2-----優化2

[cpp] view plaincopy

  1. void QuickSort(int R[], int n)  
  2. {  
  3.     int i,j;  
  4.     int pivot;  
  5.   
  6.   
  7.     int & iLeft=R[0];  
  8.     int & iRight=R[n-1];  
  9.     int & iMiddle=R[(n-1)/2];  
  10.   
  11.     //  目的為了使  準則值R[low] 為這三個值的中間值  
  12.   
  13.     int temp;  
  14.   
  15.     if (iLeft>iMiddle)  
  16.     {  
  17.         temp=iMiddle;  
  18.         iMiddle=iLeft;  
  19.         iLeft=temp;  
  20.     }  
  21.   
  22.     if (iRight>iMiddle)  
  23.     {  
  24.         temp=iMiddle;  
  25.         iMiddle=iRight;  
  26.         iRight=temp;  
  27.     }  
  28.   
  29.     if (iLeft<iRight)  
  30.     {  
  31.         temp=iRight;  
  32.         iRight=iLeft;  
  33.         iLeft=iRight;  
  34.     }  
  35.   
  36.     i=0;  
  37.     j=n-1;  
  38.     pivot=R[i]; //  此時R[0]為 上述三值得中間值  
  39.   
  40.   
  41.   
  42.     do   
  43.     {  
  44.         while((R[j]>=pivot)&&(i<j)) j--;  
  45.         if(i<j) R[i++]=R[j];  
  46.   
  47.         while(R[i]<pivot&&(i<j)) i++;  
  48.         if(i<j) R[j--]=R[i];  
  49.   
  50.     } while (i!=j);  
  51.   
  52.     R[i]=pivot;  
  53.   
  54.     /* 
  55.     if(i>1) QuickSort(R,i); 
  56.     if(n-i-1>1) QuickSort(&R[i+1],n-i-1); 
  57.     */  
  58.   
  59.     if(i>30)   
  60.         QuickSort(R,i);  
  61.     else  
  62.         StraightSelectionSort(R,i);  
  63.   
  64.   
  65.     if (n-i-1>30)  
  66.         QuickSort(R,n-i-1);  
  67.     else  
  68.         StraightSelectionSort(&R[i+1],n-i-1);  
  69.   
  70.   
  71. }  


 

 

[cpp] view plaincopy

  1. void StraightSelectionSort(int *p, int n)  
  2. {  
  3.     int i,j,t;  
  4.     int indexMax;  
  5.     for (i=0;i<n;i++)  // 0....n-1  
  6.     {  
  7.         // 未排元素 0...n-1-i   以排元素 n-i...n-1  
  8.         for (j=0,indexMax=0;j<n-i;j++)  
  9.         {  
  10.             if (p[j]>=p[indexMax])  
  11.             {  
  12.                 indexMax=j;  
  13.             }  
  14.         }  
  15.         t=p[n-i-1];  
  16.         p[n-i-1]=p[indexMax];  
  17.         p[indexMax]=t;  
  18.     }  
  19. }  

相關推薦

基礎演算法--排序：之快速排序

與簡單排序不同，快序排序所需的比較次數較少，是內部排序中速度較快的一種排序方法。    演算法思想： 分-------------- 將待排序集合劃分為2部分 （一部分小於準則值，一部分大於等於準則值）      &n

基礎演算法--排序： 之插入排序

氣泡排序兩兩比較指的是： 未排序的相鄰元素之間的兩兩比較，對於已排好的元素，它不再訪問。          而插入排序中的比較則是： 在未排序的元素中，取出一個，將它與已排好的元素進行比較，從而確定其位置。&nb

基礎演算法--排序： 之氣泡排序

 氣泡排序，是所有排序中用的最多和最易想起的一種排序演算法。      其排序思想： 對未排序的相鄰元素進行兩兩比較，找出未排序元素中的最值，並將其置入應有位置。     演算法特點：   &n

礎演算法--排序： 之選擇排序

三種簡單排序的區別：      氣泡排序是 未排序部分，相鄰元素之間兩兩比較移動，從而找出最值。      插入排序是 某個待排序元素與以排元素兩兩比較，   從而找到待排元素所應在

排序入門之快速排序簡單入門

本文章只是簡單講解快速排序的原理，並沒有深入進行討論 希望這篇文章適合你  :) 快速排序被廣泛認為它是解決一般問題的最佳排序演算法，它比較適合解決大規模資料的排序。 原理思想：（順序是從小到大） 快速排序首先選取一個“基準數”，通過基準數將大於它和小於它的數

排序演算法之快速排序（關鍵詞：資料結構/演算法/排序演算法/快速排序）

快速排序 實現 def partition(nums, left, right): middle = (left+right) // 2 pivot = nums[middle] swap(nums, middle, right) # 現在主元 pivot 等於 num

機試演算法講解：第2題 結構體之快速排序

/* 題目: 學生成績排序：成績從低到高，姓名字母從低到高（區分大小寫），年齡從低到高排序 輸入: 3 abc 20 99 bcd 19 97 bed 20 97 輸出: bcd 19 97 bed 20 97 abc 20 99 易錯點: 1對於字元指標，scanf(

Java常用的八種排序演算法與程式碼實現（二）：歸併排序法、快速排序法

注：這裡給出的程式碼方案都是通過遞迴完成的 －－－ 歸併排序（Merge Sort）： 　　分而治之，遞迴實現 　　如果需要排序一個數組，我們先把陣列從中間分成前後兩部分，然後對前後兩部分進行分別排序，再將排好序的數組合並在一起，這樣整個陣列就有序了 　　歸併排序是穩定的排序演算法，時間

經典排序演算法之--快速排序

快速排序是一種高效但不穩的排序演算法，不穩性取決於比較基數的選擇帶有隨機性，其排序原理應用百度百科如下： 設要排序的陣列是A[0]……A[N-1]，首先任意選取一個數據（通常選用陣列的第一個數）作為關鍵資料，然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一趟快速排

c#程式碼實現排序演算法之快速排序

快速排序的平均時間複雜度為O（nlog2n），最好時間複雜度為O（nlog2n），最壞時間複雜度為O（n²），空間複雜度為O（log2n），是一種不穩定的演算法。 1.劃分：選定一個記錄作為軸值，以軸值為基準將整個序列劃分為兩個子序列r(1)…r(i-1)和r(i+1)…r(n)

演算法導論 第七章：快速排序 筆記（快速排序的描述、快速排序的效能、快速排序的隨機化版本、快速排序分析）

快速排序的最壞情況時間複雜度為Θ(n^2)。雖然最壞情況時間複雜度很差，但是快速排序通常是實際排序應用中最好的選擇，因為它的平均效能很好。它的期望執行時間複雜度為Θ(n lg n)，而且Θ(n lg n)中蘊含的常數因子非常小，而且它還是原址排序的。 快速排序是一種排序演算法，對包含n個數的

資料結構與演算法C++之快速排序（續）

上一篇部落格資料結構與演算法C++之快速排序介紹了快速排序演算法。 但是上面實現的快速排序有兩個缺點： （一）對於近乎有序的陣列，演算法的計算複雜度由O(nlogn)退化到O(n2) （二）如果陣列中存在大量重複的元素，那麼演算法的計算複雜度也會退化到O(n2) （一）對於近乎有序的

資料結構與演算法C++之快速排序

快速排序是一種比歸併排序還要快的排序演算法，具體原理如下圖所示 對上圖所示的陣列，首先隨機選取一個參照元素，一般選取最左邊的元素4為參照元素，然後將陣列排序成以4為分界點，左邊都是小於4的元素，右邊都是大於4的元素，按照這種方式進行不斷遞迴，就可實現整個陣列的排序。 上圖顯示的是程式

排序演算法大雜燴之快速排序

排序演算法大雜燴主幹文章傳送門 快速排序 接著主文章結構繼續分析快速排序 快速排序實現主流上分為兩種，第一種為快排的開山鼻祖 C

常見排序演算法之快速排序

文章目錄 前言 思路 實現過程 基本演算法 切分方法 複雜度分析 最優時間複雜度的數學證明 演算法改進 切換到插入排序 三取樣切分 三向

PHP排序演算法之快速排序

原理：找到當前陣列中的任意一個元素（一般選擇第一個元素），作為標準，新建兩個空陣列left、rignt，遍歷整個陣列元素，如果遍歷到的元素比當前的元素小就放到陣列left，比當前的元素大放到rignt，然後再對新陣列進行同樣的操作。 遞迴：遞迴是一種函式呼叫自身的機制。遞迴必須要有邊界條件，也就是遞迴出口（

排序演算法之快速排序【java實現】

快速排序是最常用的排序演算法之一，它的平均時間複雜度是O(nlogn)，但是它是一個不穩定的演算法。 步驟： 我們要找到一個基值，將小於基值的放在它的左邊，大於它的放在它的右邊。基值我們直接用陣列最左邊的值就行。每次排序會把基值放在正確的位置上，在根據這個值把陣列分成左右兩部分，在進行遞迴處

java版排序演算法之快速排序

快速排序的思想 快速排序是通過切分的方式將大陣列切分為左右兩個子陣列，分別對兩個子陣列進行遞迴的切分，當左右兩個子陣列都有序時整個陣列便有序了。 程式碼實現 public clas

資料結構與演算法之快速排序

快速排序顧名思義，在大部分情況下都能快速的將資料進行排序。百度百科快速排序的定義：通過一趟排序將要排序的資料分成獨立的兩部分，其中一部分的資料比另一部分的所有資料都要小，然後再按照這個方法對這兩部分進行快速排序，排序以遞迴進行，從而達到將整個資料變成有序序列。快速排序的平均執

排序演算法之快速排序的非遞迴實現

在之前的部落格中提到過快速排序的三種實現方式，不過都是通過遞迴來實現，今天我們將會利用棧來實現快速排序。 -----------------------------------Stack.h----------------------------------------