快排的非遞歸實現

給了一個用遞歸實現的快排的代碼,要求改寫成用棧實現的ios

#include<iostream>數組

 #include<vector>dom

 #include<stack>ui

 #include<cstdlib>spa

 #include<algorithm>排序

 using namespace std;遞歸

  一次劃分方法,返回mid元素ci

 /**把數組分爲兩部分,軸pivot左邊的部分都小於軸右邊的部分**/it

 template <typename Comparable>io

 int partition(vector<Comparable> &vec,int low,int high){

     Comparable pivot=vec[low];  //任選元素做爲軸,這裏選首元素

     while(low<high){

         while(low<high && vec[high]>=pivot)

             high--;

         vec[low]=vec[high];

         while(low<high && vec[low]<=pivot)

             low++;

         vec[high]=vec[low];

     }

     //此時low==high

     vec[low]=pivot;

     return low;

 }

 

 /**使用遞歸快速排序**/

 template<typename Comparable>

 void quicksort1(vector<Comparable> &vec,int low,int high){

     if(low<high){

         int mid=partition(vec,low,high);

         quicksort1(vec,low,mid-1);

         quicksort1(vec,mid+1,high);

     }

 }

 

 /**使用棧的非遞歸快速排序**/

 template<typename Comparable>

 void quicksort2(vector<Comparable> &vec,int low,int high){

     stack<int> st;

     if(low<high){

         int mid=partition(vec,low,high);//一次劃分以後,把四個元素入站

         if(low<mid-1){

             st.push(low);

             st.push(mid-1);

         }

         if(mid+1<high){

             st.push(mid+1);

             st.push(high);

         }

         //其實就是用棧保存每個待排序子串的首尾元素下標,下一次while循環時取出這個範圍,對這段子序列進行partition操做

         while(!st.empty()){

             int q=st.top();

             st.pop();

             int p=st.top();

             st.pop();

             mid=partition(vec,p,q);

//當劃分到最大的len-1和len-2個元素時,下面的判斷就不執行了,而後把棧頂這兩個元素彈出,而後棧不爲空,繼續彈出,執行下面的判斷。最後站元素所有彈出。。

             if(p<mid-1){

                 st.push(p);

                 st.push(mid-1);

             }

             if(mid+1<q){

                 st.push(mid+1);

                 st.push(q);

             }      

         }

     }

 }

 

 

 

 int main(){

     int len=1000000;

     vector<int> vec;

     for(int i=0;i<len;i++)

         vec.push_back(rand());

     clock_t t1=clock();

     quicksort1(vec,0,len-1);

     clock_t t2=clock();

     cout<<"recurcive  "<<1.0*(t2-t1)/CLOCKS_PER_SEC<<endl;

     

     //從新打亂順序

     random_shuffle(vec.begin(),vec.end());

         

     t1=clock();

     quicksort2(vec,0,len-1);

     t2=clock();

     cout<<"none recurcive  "<<1.0*(t2-t1)/CLOCKS_PER_SEC<<endl;

     

     return 0;

 }

相關文章
相關標籤/搜索