十二之再续：快速排序算法之所有版本的c/c++实现

最新推荐文章于 2024-03-15 17:22:03 发布
最新推荐文章于 2024-03-15 17:22:03 发布
阅读量8.6w 收藏 270
点赞数 5
分类专栏： 十五大经典算法研究 文章标签： 算法 distance exchange pivot 测试 recursion
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/v_july_v/article/details/6262915
版权

                    十二之再续、快速排序算法所有版本的c/c++实现


作者：July、二零一一年三月二十日。
出处：http://blog.csdn.net/v_JULY_v。
--------------------------------------------------

 

前言：

    相信，经过本人之前写的前俩篇关于快速排序算法的文章：第一篇、一、快速排序算法，及第二篇、一之续、快速排序算法的深入分析，各位，已经对快速排序算法有了足够的了解与认识。但仅仅停留在对一个算法的认识层次上，显然是不够的，即便你认识的有多透彻与深入。最好是，编程实现它。
    而网上，快速排序的各种写法层次不清，缺乏统一、整体的阐述与实现，即，没有个一锤定音，如此，我便打算自己去实现它了。

    于是，今花了一个上午，把快速排序算法的各种版本全部都写程序一一实现了一下。包括网上有的，没的，算法导论上的，国内教材上通用的，随机化的，三数取中分割法的，递归的，非递归的，所有版本都用c/c++全部写了个遍。
    鉴于时间仓促下，一个人考虑问题总有不周之处，以及水平有限等等，不正之处，还望各位不吝赐教。不过，以下，所有全部c/c++源码，都经本人一一调试，若有任何问题，恳请指正。

    ok，本文主要分为以下几部分内容：

第一部分、递归版
一、算法导论上的单向扫描版本
二、国内教材双向扫描版
      2.1、Hoare版本
      2.2、Hoare的几个变形版本
三、随机化版本
四、三数取中分割法
第二部分、非递归版

    好的，请一一细看。


第一部分、快速排序的递归版本
一、算法导论上的版本
在我写的第二篇文章中，我们已经知道：
“再到后来，N.Lomuto又提出了一种新的版本，此版本....，即优化了PARTITION程序,它现在写在了 算法导论 一书上”：

快速排序算法的关键是PARTITION过程，它对A[p..r]进行就地重排：

PARTITION(A, p, r)
1  x ← A[r]         //以最后一个元素，A[r]为主元
2  i ← p - 1
3  for j ← p to r - 1    //注，j从p指向的是r-1，不是r。
4       do if A[j] ≤ x
5             then i ← i + 1
6                  exchange A[i] <-> A[j]
7  exchange A[i + 1] <-> A[r]    //最后，交换主元
8  return i + 1

然后，对整个数组进行递归排序：

QUICKSORT(A, p, r)
1 if p < r
2    then q ← PARTITION(A, p, r)   //关键
3         QUICKSORT(A, p, q - 1)
4         QUICKSORT(A, q + 1, r)

    根据上述伪代码，我们不难写出以下的c/c++程序：
首先是，PARTITION过程：

int partition(int data[],int lo,int hi)
{
 int key=data[hi];  //以最后一个元素，data[hi]为主元
 int i=lo-1;
 for(int j=lo;j<hi;j++)   ///注，j从p指向的是r-1，不是r。
 {
  if(data[j]<=key)
  {
   i=i+1;
   swap(&data[i],&data[j]);
  }
 }
 swap(&data[i+1],&data[hi]);   //不能改为swap(&data[i+1],&key)
 return i+1;
}

补充说明：举个例子，如下为第一趟排序（更多详尽的分析请参考第二篇文章）：
第一趟(4步)：
   a：3   8   7   1   2   5   6   4   //以最后一个元素，data[hi]为主元

   b：3   1   7   8   2   5   6   4

   c：3   1   2   8   7   5   6   4

   d：3   1   2   4   7   5   6   8    //最后，swap(&data[i+1],&data[hi])

  而其中swap函数的编写，是足够简单的： 

void swap(int *a,int *b)
{
 int temp=*a;
 *a=*b;
 *b=temp;
}

    然后是，调用partition，对整个数组进行递归排序：

void QuickSort(int data[], int lo, int hi)
{
    if (lo<hi)
    {
        int k = partition(data, lo, hi);
        QuickSort(data, lo, k-1);
        QuickSort(data, k+1, hi);
    }
} 

     现在，我有一个问题要问各位了，保持其它的不变，稍微修改一下上述的partition过程，如下：

int partition(int data[],int lo,int hi)   //请读者思考
{
 int key=data[hi];  //以最后一个元素，data[hi]为主元
 int i=lo-1;
 for(int j=lo;j<=hi;j++)   //现在，我让j从lo指向了hi，不是hi-1。
 {
  if(data[j]<=key)
  {
   i=i+1;
   swap(&data[i],&data[j]);
  }
 }
 //swap(&data[i+1],&data[hi]);   //去掉这行
 return i;                       //返回i，非i+1.
}

    如上，其它的不变，请问，让j扫描到了最后一个元素，后与data[i+1]交换，去掉最后的swap(&data[i+1],&data[hi])，然后，再返回i。请问，如此，是否可行？
    其实这个问题，就是我第二篇文章中，所提到的：
    “上述的PARTITION(A, p, r)版本，可不可以改成这样咧?以下这样列”：

PARTITION(A, p, r)   //请读者思考版本。
1  x ← A[r]
2  i ← p - 1
3  for j ← p to r      //让j 从p指向了最后一个元素r
4       do if A[j] ≤ x
5             then i ← i + 1
6                  exchange A[i] <-> A[j]
//7  exchange A[i + 1] <-> A[r]   去掉此最后的步骤
8  return i      //返回 i，不再返回 i+1.

    望读者思考，后把结果在评论里告知我。

    我这里简单论述下：上述请读者思考版本，只是代码做了以下三处修改而已：1、j从 p->r；2、去掉最后的交换步骤；3、返回 i。首先，无论是我的版本，还是算法导论上的原装版本，都是准确无误的，且我都已经编写程序测试通过了。但，其实这俩种写法，思路是完全一致的。

    为什么这么说列?请具体看以下的请读者思考版本，

int partition(int data[],int lo,int hi)   //请读者思考
{
 int key=data[hi];  //以最后一个元素，data[hi]为主元
 int i=lo-1;
 for(int j=lo;j<=hi;j++)   //....
 {
  if(data[j]<=key)           //如果让j从lo指向hi，那么当j指到hi时，是一定会有A[j]<=x的
  {
   i=i+1;
   swap(&data[i],&data[j]);
  }
 }
 //swap(&data[i+1],&data[hi]);   //事实是，应该加上这句，直接交换，即可。
 return i;                       //
}

    我们知道当j最后指到了r之后，是一定会有A[j]<=x的（即=），所以这个if判断就有点多余，没有意义。所以应该如算法导论上的版本那般，最后直接交换swap(&data[i+1],&data[hi]);   即可，返回i+1。所以，总体说来，算法导论上的版本那样写，比请读者思考版本更规范，更合乎情理。ok，请接着往下阅读。

   

    当然，上述partition过程中，也可以去掉swap函数的调用，直接写在分割函数里：

int partition(int data[],int lo,int hi)
{
 int i,j,t;
 int key = data[hi];   //还是以最后一个元素作为哨兵，即主元元素
 i = lo-1;
 for (j =lo;j<=hi;j++)
  if(data[j]<key)
  {
   i++;
   t = data[j];
   data[j] = data[i];
   data[i] = t;
  }
  data[hi] = data[i+1];  //先,data[i+1]赋给data[hi]
  data[i+1] = key;       //后，把事先保存的key值，即data[hi]赋给data[i+1]
  //不可调换这俩条语句的顺序。
  return i+1;
}

提醒：
1、程序中尽量不要有任何多余的代码。
2、你最好绝对清楚的知道，程序的某一步，是该用if，还是该用while，等任何细节的东西。

   ok，以上程序的测试用例，可以简单编写如下：

int main()
{
 int a[8]={3,8,7,1,2,5,6,4};
 QuickSort(a,0,N-1);
 for(int i=0;i<8;i++)
  cout<<a[i]<<endl;
 return 0;
}

    当然，如果，你如果对以上的测试用例不够放心，可以采取1~10000的随机数进行极限测试，保证程序的万无一失（主函数中测试用的随机数例子，即所谓的“极限”测试，下文会给出）。
    至于上述程序是什么结果，相信，不用我再啰嗦。:D。

补充一种写法：

void quickSort(int p, int q)  
{  
 if(p < q)  
 {  
  int x = a[p];    //以第一个元素为主元
  int i = p;  
  for(int j = p+1; j < q; j++)  
  {  
   if(a[j] < x)  
   {  
    i++;  
    int temp = a[i];  
    a[i] = a[j];   
    a[j] = temp;  
   }  
  }  
  int temp = a[p];  
  a[p] = a[i];  
  a[i] = temp;  
  quickSort(p, i);  
  quickSort(i+1, q);  
 }  
}  


二、国内教材双向扫描版
    国内教材上一般所用的通用版本，是我写的第二篇文章中所提到的霍尔排序或其变形，而非上述所述的算法导论上的版本。而且，现在网上一般的朋友，也是更倾向于采用此种思路来实现快速排序算法。ok，请看：
          2.1、Hoare版本
    那么，什么是霍尔提出的快速排序版本列?如下，即是：

HOARE-PARTITION(A, p, r)
 1  x ← A[p]
 2  i ← p - 1
 3  j ← r + 1
 4  while TRUE
 5      do repeat j ← j - 1
 6           until A[j] ≤ x
 7         repeat i ← i + 1
 8           until A[i] ≥ x
 9         if i < j
10            then exchange A[i] <-> A[j]
11            else return j

     同样，根据以上伪代码，不难写出以下的c/c++代码：

 或者原来的代码修改成这样（已经过测试，有误）：

int partition(int data[],int lo,int hi)  //。
{
 int key=data[lo];
 int l=lo;
 int h=hi;
 for(;;)
 {
  while(data[h]>key)   //不能加 “=”
   h--;
  while(data[l]<key)    //不能加 “=”
   l++;
  if(l<h)
  {
   swap(data[l],data[h]);
  }
  else
  {
   return h;   //各位注意了，这里的返回值是h。不是返回各位习以为常的枢纽元素，即不是l之类的。
  }
 }
} //这个版本，已经证明有误，因为当data[l] == data[h] == key的时候，将会进入死循环，所以淘汰。因此，使用上面的do-while 形式吧。

    读者可以试下，对这个序列进行排序，用上述淘汰版本将立马进入死循环：int data[16]={ 1000, 0, 6, 5, 4, 3, 2, 1, 7, 156, 44, 23, 123, 11, 5 };。

或者，如朋友颜沙所说：
如果data数组有相同元素就可能陷入死循环，比如：
      2 3 4 5 6 2 
  l->|             |<-h

交换l和h单元后重新又回到：
      2 3 4 5 6 2 
  l->|             |<-h

而第一个程序不存在这种情况，因为它总是在l和h调整后比较，也就是l终究会大于等于h。

.

    相信，你已经看出来了，上述的第一个程序中partition过程的返回值h并不是枢纽元的位置，但是仍然保证了A[p..j] <= A[j+1...q]。
    这种方法在效率上与以下将要介绍的Hoare的几个变形版本差别甚微，只不过是上述代码相对更为紧凑点而已。

       2.2、Hoare的几个变形版本
    ok，可能，你对上述的最初的霍尔排序partition过程，理解比较费力，没关系，我再写几种变形，相信，你立马就能了解此双向扫描是怎么一回事了。

int partition(int data[],int lo,int hi)  //双向扫描。
{
 int key=data[lo];   //以第一个元素为主元
 int l=lo;
 int h=hi;
 while(l<h)
 {
  while(key<=data[h] && l<h)
   h--;
  data[l]=data[h];
  while(data[l]<=key && l<h)
   l++;
  data[h]=data[l];
 }
 data[l]=key;  //1.key。只有出现要赋值的情况，才事先保存好第一个元素的值。
 return l;     //这里和以下所有的Hoare的变形版本都是返回的是枢纽元素，即主元元素l。
}

补充说明：同样，还是举上述那个例子，如下为第一趟排序（更多详尽的分析请参考第二篇文章）：
第一趟(五步曲)：
   a：3   8   7   1   2   5   6   4   //以第一个元素为主元
        2   8   7   1       5   6   4
   b：2       7   1   8   5   6   4
   c：2   1   7       8   5   6   4
   d：2   1       7   8   5   6   4
   e：2   1   3   7   8   5   6   4   //最后补上，关键字3

然后，对整个数组进行递归排序：

void QuickSort(int data[], int lo, int hi)
{
    if (lo<hi)
    {
        int k = partition(data, lo, hi);
        QuickSort(data, lo, k-1);
        QuickSort(data, k+1, hi);
    }
}

当然，你也可以这么写，把递归过程写在同一个排序过程里：

void QuickSort(int data[],int lo,int hi)
{
   int i,j,temp;
   temp=data[lo];    //还是以第一个元素为主元。
   i=lo;
   j=hi;
   if(lo>hi)
      return;
   while(i!=j)
   {
      while(data[j]>=temp && j>i)
         j--;
      if(j>i)
         data[i++]=data[j];
      while(data[i]<=temp && j>i)
         i++;
      if(j>i)
   data[j--]=data[i];    
   }
   data[i]=temp;                       //2.temp。同上，返回的是枢纽元素，即主元元素。
   QuickSort(data,lo,i-1);  //递归左边
   QuickSort(data,i+1,hi);  //递归右边
}

  或者，如下：

另，本人在一本国内的数据结构教材上（注，此处非指严那本），看到的一种写法，发现如下问题：一、冗余繁杂，二、错误之处无所不在，除了会犯一些注释上的错误，一些最基本的代码，都会弄错。详情，如下：

void QuickSort(int data[],int lo,int hi)
{
 int i,j,key;
 if(lo<hi)
 {
  i=lo;
  j=hi;
  key=data[lo];
  //已经测试：原教材上，原句为“data[0]=data[lo];”，有误。
  //因为只能用一个临时变量key保存着主元，data[lo]，而若为以上，则相当于覆盖原元素data[0]的值了。
        do
        {
   while(data[j]>=key&&i<j)
    j--;       
   if(i<j)                            
   {
    data[i]=data[j];
    //i++;  这是教材上的语句，为使代码简洁，我特意去掉。
   }          
   while(data[i]<=key&&i<j)
    i++;    
   if(i<j)                      
   {
    data[j]=data[i];
    //j--;    这是教材上的语句，为使代码简洁，我特意去掉。
   }             
        }while(i!=j);
        data[i]=key;        //3.key。
  //已经测试：原教材上，原句为“data[i]=data[0];”，有误。
        QuickSort(data,lo,i-1);     //对标准值左半部递归调用本函数
        QuickSort(data,i+1,hi);    //对标准值右半部递归调用本函数
 }
}

    然后，你能很轻易的看到，这个写法，与上是同一写法，之所以写出来，是希望各位慎看国内的教材，多多质疑+思考，勿轻信。

    ok，再给出一种取中间元素为主元的实现：

void QuickSort(int data[],int lo,int hi)
{
 int pivot,l,r,temp;
 l = lo;
 r = hi;
 pivot=data[(lo+hi)/2]; //取中位值作为分界值
 while(l<r) 
 { 
  while(data[l]<pivot)
   ++l; 
  while(data[r]>pivot)
   --r;    
  if(l>=r)
   break; 
  temp = data[l]; 
  data[l] = data[r]; 
  data[r] = temp; 
  ++l; 
  --r; 
 }
 if(l==r)
  l++;
 if(lo<r)
  QuickSort(data,lo,l-1);
 if(l<hi)
  QuickSort(data,r+1,hi);
}

或者，这样写：

 void quickSort(int arr[], int left, int right)
{
 int i = left, j = right;
 int tmp;
 int pivot = arr[(left + right) / 2];   //取中间元素为主元
 
 /* partition */
 while (i <= j)
 {
  while (arr[i] < pivot)
   i++;
  while (arr[j] > pivot)
   j--;
  if (i <= j)
  {
   tmp = arr[i];
   arr[i] = arr[j];
   arr[j] = tmp;
   i++;
   j--;
  }
 }
}

上述演示过程，如下图所示（取中间元素为主元，第一趟排序）：

 


三、快速排序的随机化版本
    以下是完整测试程序，由于给的注释够详尽了，就再做多余的解释了：

//交换两个元素值，咱们换一种方式，采取引用“&”
void swap(int& a , int& b)
{
 int temp = a;
 a = b;
 b = temp;
}

//返回属于[lo,hi)的随机整数
int rand(int lo,int hi)
{
 int size = hi-lo+1;
 return  lo+ rand()%size;
}

//分割，换一种方式，采取指针a指向数组中第一个元素
int RandPartition(int* data, int lo , int hi)
{   
 //普通的分割方法和随机化分割方法的区别就在于下面三行
 swap(data[rand(lo,hi)], data[lo]);
    int key = data[lo];
 int i = lo;
 
    for(int j=lo+1; j<=hi; j++)
 {
  if(data[j]<=key)
  {
   i = i+1;
   swap(data[i], data[j]);
  }           
 } 
 swap(data[i],data[lo]);
 return i;
}

//逐步分割排序
void RandQuickSortMid(int* data, int lo, int hi)
{
 if(lo<hi)
 {
  int k = RandPartition(data,lo,hi);
  RandQuickSortMid(data,lo,k-1);
  RandQuickSortMid(data,k+1,hi);
 }
}
int main()
{
 const int N = 100; //此就是上文说所的“极限”测试。为了保证程序的准确无误，你也可以让N=10000。
 int *data = new int[N];     
    for(int i =0; i<N; i++)
  data[i] = rand();   //同样，随机化的版本，采取随机输入。
    for(i=0; i<N; i++)
  cout<<data[i]<<" ";
    RandQuickSortMid(data,0,N-1);
 cout<<endl;
 for(i=0; i<N; i++)
  cout<<data[i]<<" ";
 cout<<endl;
    return 0;
}

 
四、三数取中分割法

    我想，如果你爱思考，可能你已经在想一个问题了，那就是，像上面的程序版本，其中算法导论上采取单向扫描中，是以最后一个元素为枢纽元素，即主元，而在Hoare版本及其几个变形中，都是以第一个元素、或中间元素为主元，最后，上述给的快速排序算法的随机化版本，则是以序列中任一一个元素作为主元。
    那么，枢纽元素的选取，即主元元素的选取是否决定快速排序最终的效率列?
   
    答案是肯定的，当我们采取data[lo],data[mid],data[hi]三者之中的那个第二大的元素为主元时，便能尽最大限度保证快速排序算法不会出现O（N^2）的最坏情况。这就是所谓的三数取中分割方法。当然，针对的还是那个Partition过程。

    ok，直接写代码：

//三数取中分割方法
int RandPartition(int* a, int p , int q)
{   
 //三数取中方法的关键就在于下述六行，
 int m=(p+q)/2;
 if(a[p]<a[m])
  swap(a[p],a[m]);
 if(a[q]<a[m])
  swap(a[q],a[m]);
 if(a[q]<a[p])
  swap(a[q],a[p]);
 int key = a[p];
 int i = p;
 
 for(int j = p+1; j <= q; j++)
 {
  if(a[j] <= key)
  {
   i = i+1;
   if(i != j)
    swap(a[i], a[j]);                
  }           
 }
 
 swap(a[i],a[p]);  
 return i;
}

void QuickSort(int data[], int lo, int hi)
{
    if (lo<hi)
    {
        int k = RandPartition(data, lo, hi);
        QuickSort(data, lo, k-1);
        QuickSort(data, k+1, hi);
    }
}

    经过测试，这种方法可行且有效，不过到底其性能、效率有多好，还有待日后进一步的测试。


第二部分、快速排序的非递归版
    ok，相信，您已经看到，上述所有的快速排序算法，都是递归版本的，那还有什么办法可以实现此快速排序算法列?对了，递归，与之相对的，就是非递归了。
    以下，就是快速排序算法的非递归实现：

  template <class T>
int RandPartition(T data[],int lo,int hi)
{
 T v=data[lo];
 while(lo<hi)
 { 
  while(lo<hi && data[hi]>=v)
   hi--;
  data[lo]=data[hi];
  while(lo<hi && data[lo]<=v)
   lo++;
  data[hi]=data[lo];
 }
 data[lo]=v;
 return lo;
}

//快速排序的非递归算法
template <class T>
void QuickSort(T data[],int lo,int hi)
{
 stack<int> st;
 int key;
 do{
  while(lo<hi)
  {
   key=partition(data,lo,hi);  
   //递归的本质是什么?对了，就是借助栈，进栈，出栈来实现的。
   if( (key-lo)<(key-hi) )
   {
    st.push(key+1);   
    st.push(hi);
    hi=key-1;
   }
   else
   {
    st.push(lo);
    st.push(key-1);
    lo=key+1;
   }  
  }
  if(st.empty())
   return;
  hi=st.top();
  st.pop(); 
  lo=st.top();
  st.pop(); 
 }while(1);
}

void QuickSort(int data[], int lo, int hi)
{
    if (lo<hi)
    {
        int k = RandPartition(data, lo, hi);
        QuickSort(data, lo, k-1);
        QuickSort(data, k+1, hi);
    }
}

    如果你还尚不知道快速排序算法的原理与算法思想，请参考本人写的关于快速排序算法的前俩篇文章：一之续、快速排序算法的深入分析，及一、快速排序算法。如果您看完了此篇文章后，还是不知如何从头实现快速排序算法，那么好吧，伸出手指，数数，1,2,3,4,5....数到100之后，再来看此文。

    -------------------------------------------------------------
    据本文评论里头网友ybt631的建议，表示非常感谢，并补充阐述下所谓的并行快速排序：

    Intel Threading Building Blocks(简称TBB)是一个C++的并行编程模板库，它能使你的程序充分利用多核CPU的性能优势，方便使用，效率很高。
    以下是，parallel_sort.h头文件中的关键代码：

    再贴一下插入排序、快速排序之其中的俩种版本、及插入排序与快速排序结合运用的实现代码，如下：

 

版权所有。转载本BLOG内任何文章，请以超链接形式注明出处。
否则，一经发现，必定永久谴责+追究法律责任。谢谢，各位。

v_JULY_v
关注
  • 5
    点赞
  • 踩
  • 270
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 100
    评论
专栏目录
C/C++实现三路快速排序算法原理
01-01
书接上文，上次讲到了双路快速排序，双路快速排序是将等于v（标志数）的数也进行交换，从而避免了在处理有大量重复数据的数组分组时的不平衡。而三路快速排序则是将等于v的数也分成一组，同样可以解决上述问题。其...
快速排序递归与非递归超详细讲解C语言
Codenange的博客
08-28 2403
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。快速排序又是一种分而治之思想在排序算法上的典型应用。...
数据结构（C语言实现）——常见排序算法的基本思想及实现（快速排序的三种方法和优化及非递归实现快速排序）
_Fiora的博客
04-22 1365
本文介绍了几种数据结构中常见的排序算法，着重讲解了快速排序的三种实现方法，并优化了快速排序，还通过非递归的方式实现了快速排序
C++实现快速排序算法
最新发布
学IT的细胞膜的博客
03-15 238
C++1实现快速排序
快速排序（递归与非递归）c语言实现
qq_52496633的博客
02-15 2252
1、算法设计原理分析 快速排序是对冒泡排序的一种改进，快速排序的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另一部分的所有数据要小，再按这种方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，使整个数据变成有序序列。 基本步骤为：1）先从数列中取出一个数作为基准数；2）分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。3）再对左右区间重复第二步，直到各区间只有一个数。 非递归实现方法，需要把递归实现中函数调用部分换为迭代中调用函数，
C语言快速排序（非递归）图文详解
yao_yao0524的博客
01-24 900
用C语言实现快速排序的非递归，借助了栈模拟了递归的实现。
C++实现快速排序（非递归版）
Jayler_May的博客
06-22 1389
#include <iostream> #include<time.h> #define LEN 100 using namespace std; int partition(int* a, int left, int right) { double x = a[right]; int i = left-1, j = right; for (;;) { wh...
快速排序的两种实现思路和非递归实现--C++实现
CodePikachu的博客
09-14 6274
思路一：        第一种是根据算法导论上的思想：取数组的最后一个元素为主元，i初始化为最低位元素的前一个位置，j指向遍历数组中待排序的元素，当j所指元素比主元小的时候i= i + 1，然后交换i和j所指的元素，j不断遍历，遇到小于主元的就进行交换，这样就能一直维持这样一个序列，i之前的元素(包括i所指元素本身)都是比主元小的元素，i到j之间都是比主元大的元素，j(包括j所指元素)之后都是待排
快速排序算法C++实现（超详细解析！！！！）
weixin_45031801的博客
09-21 7万+
快速排序，其实是一种分治算法，那么在了解快速排序之前，我们先来看看什么是分治算法。在算法设计中，我们引入分而治之的策略，称为分治算法，其本质就是将一个大规模的问题分解为若干个规模较小的相同子问题，分而治之。
C++算法之快速排序
R_mine的博客
04-23 1万+
C++算法之快速排序 文章目录C++算法之快速排序一、快速排序引出二、代码实现三、复杂度分析 一、快速排序引出 我们知道，给一个长度为n的序列排序，有三种很简单的算法：选择排序、冒泡排序、插入排序。这三种算法的复杂度均为O(n^2)。 如果按照计算机1秒钟可以进行10^8次计算作为参照，那么它1秒之内可以排序的序列长度大概为10^4这个数量级。 然而，在实际生活中，10^4级别并不是一个很大的数字，比如说山东每年会有超过50万人参加高考。如果我们想将山东省内所有学生按照高考成绩排序的话，使用O(n^2)
排序——快速排序（Quick sort）
努力中的老周的专栏
02-09 17万+
概况 快速排序（Quick sort）是对冒泡排序的一种改进。快速排序由C. A. R. Hoare在1960年提出。 算法思路 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 快速排序算法通过多次比较和交换来实现排序，其排序流程如下： ......
C/C++实现双路快速排序算法原理
01-21
本文实例为大家分享了C/C++实现双路快速排序算法的具体代码，供大家参考，具体内容如下 看了刘宇波的视频，讲双路快速排序的，原理讲的很直观，程序讲解也一看就懂。这里写一下自己的理解过程，也加深一下自己的理解...
Verilog/C++实现排序算法：Verilog/C++实现排序算法：冒泡排序、选择排序、并行全比较排序、串行全比较排序
06-27
Verilog/C++实现排序算法：Verilog/C++实现排序算法：冒泡排序、选择排序、并行全比较排序、串行全比较排序。
快速排序（Quick sort）
雪月清的博客
07-20 8万+
一、简介 快速排序是（Quick sort）是对冒泡排序的一种改进，是非常重要且应用比较广泛的一种高效率排序算法。 二、算法思路 快速排序是通过多次比较和交换来实现排序，在一趟排序中把将要排序的数据分成两个独立的部分，对这两部分进行排序使得其中一部分所有数据比另一部分都要小，然后继续递归排序这两部分，最终实现所有数据有序。 大致步骤如下： 首先设置一个分界值也就是基准值又是也称为监视哨，通过该分界值将数据分割成两部分。 将大于或等于分界值的数据集中到右边，小于分界值的数据集中到左边。一趟排序过后，左边部
C++实现快速排序
weixin_59566851的博客
12-22 3万+
C++实现快速排序
快速排序算法——C/C++
热门推荐
有人_295的博客
06-12 24万+
快速排序 1、算法思想 快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。 2、实现原理 2.1、设置两个变量 low、high，排序开始时：low=0，high=size-1。 2.2、整个数组找基准正确位置，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面 ...
C++的并行算法：并行排序
夏天的狂风的专栏
06-11 302
排序是计算机科学中的一个基本问题，它的目标是将一个序列的元素按照某种顺序排列。在C++中，我们可以使用std::sort算法进行排序。然而，std::sort是一个顺序算法，它在一个时间点只执行一个操作。为了提高排序的性能，我们可以使用并行排序算法，它在多个处理器上同时执行多个操作。C++17标准库中的std::sort并没有并行版本，但我们可以使用其他的并行算法库，如Intel Threading Building Blocks (TBB) 或 Parallel STL，来进行并行排序。
C++并行多线程归并排序
a4364634611的博客
04-30 1728
template<typename Iterator> void F(Iterator start, Iterator end) { std::sort(start, end); } template <typename Iterator> void merge(Iterator start, int length, int size) { for (int i = 1; i < size; i++) std::inplace_merge(start, start +.
java实现快速排序(图)
临时抱不到佛脚的博客
11-02 305
快速排序 快速排序是对冒泡排序的一种改进， 它是不稳定的。由C. A. R. Hoare在1962年提出的一种划分交换排序，采用的是分治策略（一般与递归结合使用），以减少排序过程中的比较次数，它的最好情况为O(nlogn)，最坏情况为O(n^2)，平均时间复杂度为O(nlogn)。 基本思想 选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小。然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以达到全部数据变成有序。 代码
c++实现快速排序算法
09-26
代码实现了快速排序算法，以下是实现步骤： 1. 定义一个快速排序函数，接受一个整数数组、数组的起始位置和终止位置作为参数。 2. 如果起始位置大于等于终止位置，说明待排序序列只有一个元素，直接返回。 3. 定义两个指针i和j，分别指向起始位置和终止位置。 4. 将起始位置的元素作为基准数key。 5. 使用while循环来分别从右边和左边查找小于和大于基准数key的元素，并将它们交换位置。 6. 当i和j相遇时，将基准数key赋值给指针i处。 7. 递归调用快速排序函数对i左边的序列进行快速排序。 8. 递归调用快速排序函数对i右边的序列进行快速排序。 9. 在主函数中定义一个整数数组，调用快速排序函数进行排序并输出结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 100
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

v_JULY_v

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值