快排 partition

一   快排 partition 的几种写法。

int Partition1(int arr[], int lhs, int rhs) {  

int pivot = arr[rhs]; 

 int i = lhs - 1;   

 int temp; 

 for (int j = lhs; j <= rhs-1; ++j)  

{ 

 if (arr[j] < pivot) 

   {  ++i;

    temp = arr[i];  

    arr[i] = arr[j];   

    arr[j] = temp;  

   } 

}  

  arr[rhs] = arr[i+1];   

  arr[i+1] = pivot;   

  return i+1;  

}  

 int Partition2( int R[]，int i，int j)
    {
      int pivot=R[i]； 
      while(i<j){ 
        while(i<j&&R[j]>=pivot) 
          j--； 
        if(i<j) 
            R[i++]=R[j]；
        while(i<j&&R[i]<=pivot) 
            i++； 
        if(i<j) 
            R[j--]=R[i]; 
       } 
      R[i]=pivot； 
      return i；
    }

int Partition3(int arr[], int lhs, int rhs) {  

int pivot = arr[rhs]; 

 int i = lhs ;   

 int temp; 

 for (int j = lhs; j <= rhs-1; ++j)  

{ 

 if (arr[j] < pivot) 

{ 

    if(i!=j)

   { 

    temp = arr[i];  

    arr[i] = arr[j];   

    arr[j] = temp;  

   } 

     ++i;

}

}  

  arr[rhs] = arr[i];   

  arr[i] = pivot;  

  return i;  

}  

二   除了用于快排算法。partition还可以用来求最小的k个数，并且时间复杂度为0（n）。

求最小的k个数，一般可直接排序然后输入前k个数，或者利用最小堆输出，但是时间复杂度为0（nlogn）。

下面给出两种最小k个数的算法。

1. void quick(int data[], int low, int high ,int k)  
2. {  
3.     int i = low, j = high, tmp = data[low];  
4.   
5.     if (low < high)  
6.     {  
7.        
8.   
9.         while (i < j)  
10.         {  
11.             while(i < j && data[j] >= tmp)    
12.             {  
13.                 j--;    
14.             }  
15.             if(i < j)                       
16.             {  
17.                 data[i++] = data[j];  
18.             }  
19.               
20.             while(i < j && data[i] < tmp) 
21.             {  
22.                 i++;    
23.             }  
24.             if(i < j)   
25.             {  
26.                 data[j--] = data[i];  
27.             }  
28.         }  
29.   
30.         data[i] = tmp;                
31.   
32.         if( i == k )                   
33.         {  
34.             return;  
35.         }  
36.   
37.         quick(data, low, i - 1, k);      
38.   
39.         if( i > k )                     
40.         {  
41.             return ;  
42.         }  
43.   
44.         quick(data, i + 1, high, k);  
45.   
46.     }  
47. }  

1. int quick2(int data[], int low, int high， int k)  
2. {  
3.      int index=partition（data，low，high）
4.         while (index != k-1)  
5.         {  
6.            if（index>（k-1））
7.               index=partition（data，low，high-1）;

                                              else                

                       index=partition（data，low+1，high）;}}