非递归的快速排序算法

最新推荐文章于 2024-07-12 22:29:04 发布
最新推荐文章于 2024-07-12 22:29:04 发布
阅读量6.8k 收藏 2
点赞数
分类专栏： C++ 文章标签： 算法 pivot integer input null output

本节用非递归算法来实现快速排序算法，通常非递归算法用栈来实现，本节先介绍使用栈的非递归算法，然后介绍一个不使用栈的非递归算法。

    1. 使用栈的非递归算法

    使用栈的非递归算法编码如下。
    /** 快速排序算法的使用栈的非递归算法函数
    @param SORTTABLE *pTable——排序表指针
    @param UINT uStart——表中要排序数据区间的起点，为数组下标
    @param UINT uEnd——表中要排序数据区间的终点，为数组下标
    @param COMPAREFUNC CompareFunc——数据比较函数
    @return void——无
    void SortTable_QuickSort2( SORTTABLE *pTable，UINT uStart，UINT uEnd，
    COMPAREFUNC CompareFunc)
    { 
        STACK *pStack； 
        UINT uLow； 
        UINT uHigh； 
        UINT uMid； 
        uLow = uStart； 
        uHigh = uEnd； 
        pStack = Stack_Create(uHigh - uEnd)； 
        (void)Stack_Push(pStack，(void *)uLow)； 
        (void)Stack_Push(pStack，(void *)uHigh)； 
        while ( !Stack_IsEmpty(pStack) ) 
        { 
            uHigh = (UINT)Stack_Pop(pStack)； 
            uLow = (UINT)Stack_Pop(pStack)； 


            if ( uLow < uHigh ) 
            { 
                uMid = SortTable_Split(pTable，uLow，uHigh，CompareFunc )； 
                if ( uMid > uLow ) 
                { 
                    (void)Stack_Push(pStack，(void *)uLow )； 
                    (void)Stack_Push(pStack，(void *)(uMid－1 ))； 
                } 
                if ( uHigh > uMid ) 
                { 
                    (void)Stack_Push(pStack，(void *)(uMid + 1) )； 
                    (void)Stack_Push(pStack，(void *)uHigh)； 
                } 
            } 
            Stack_Destroy(pStack，NULL)； 
        }
    }

    在使用栈的非递归算法中，要频繁调用栈的操作函数，函数调用的开销是很大的，如果把栈操作改成不用栈函数调用，则效率会有所提高。

    2. 不使用栈的非递归算法

    不使用栈函数调用的非递归算法编码如下。
    /** 排序表的快速排序函数，不使用栈调用的非递归算法，将指定区间的数据用快速排序算
    法排好
    @param SORTTABLE *pTable——排序表指针
    @param UINT uStart——要排序的区间起点
    @param UINT uEnd——要排序的区间终点
    @param COMPAREFUNC CompareFunc——数据比较函数
    @return void——无
    */
    void SortTable_QuickSort( SORTTABLE *pTable，UINT uStart，UINT uEnd，
    COMPAREFUNC CompareFunc)
    { 
        UINT *puStack； 
        UINT uStackTop；  软件开发网 www.mscto.com
        UINT uLow； 
        UINT uHigh； 
        UINT uMid；
 if ( uEnd－uStart < 1 )
        { 
            return； 
        } 
        uLow = uStart； 
        uHigh = uEnd； 
        puStack = (UINT *)malloc((uHigh－uLow + 1) *sizeof(UINT))； 
        if ( puStack == NULL ) 
        { 
            return CAPI_FAILED； 
        } 
        uStackTop = 0； 
        puStack[uStackTop] = uLow； 
        ++uStackTop； 
        puStack[uStackTop] = uHigh； 
        ++uStackTop； 
        while ( uStackTop != 0 ) 
        { 
            －－uStackTop； 
            uHigh = puStack[uStackTop]； 
            －－uStackTop； 
            uLow = puStack[uStackTop]； 
            if ( uLow < uHigh ) 
            { 
                uMid = SortTable_Split(pTable，uLow，uHigh，CompareFunc )； 
                if ( uMid－uLow > uHigh－uMid ) 
                { 
                    puStack[uStackTop] = uLow； 
                    ++uStackTop； 
                    puStack[uStackTop] = uMid－1； 
                    ++uStackTop； 
                    if ( uHigh > uMid ) 
                    { 
                        puStack[uStackTop] = uMid + 1； 
                        ++uStackTop； 
                        puStack[uStackTop] = uHigh； 
                        ++uStackTop； 
                    } 

软件开发网 www.mscto.com


                } 
                else 
                { 
                    puStack[uStackTop] = uMid + 1； 
                    ++uStackTop； 
                    puStack[uStackTop] = uHigh； 
                    ++uStackTop； 
                    if ( uMid > uLow ) 
                    { 
                        puStack[uStackTop] = uLow； 
                        ++uStackTop； 
                        puStack[uStackTop] = uMid－1； 
                        ++uStackTop； 
                    } 
                } 
            } 
        } 
        free( puStack )；
    }

    至此，我们介绍了快速排序算法的三个不同版本：递归实现、使用栈的非递归实现、不使用栈的非递归实现。在这里需要讨论一下递归算法和非递归算法的效率问题。

 

 

=============================================================================

 

非递归的方式实现快速排序

     前段看到过一个问题（忘记在哪里了），用非递归的方式实现快速排序，今天又翻了出来，把代码贴上，给自己以后留个参考，代码中包括自己当时对程序改进的过程，请大家多提意见。

#include "stdafx.h"

#include <iostream>

#include <stack>

 

#define MAX_SIZE      10

using namespace std;

 

typedef int elem;

typedef std::stack<int> Stack;

 

int partition(elem *pData, int low, int high);

void swap(elem& a, elem& b);

void qsort(elem* pData, int low, int high);

void qsort2(elem* pData, int low, int high);

void qsort3(elem* pData, int low, int high);

 

int partition(elem *pData, int low, int high)

{

       elem key = pData[low];

 

       while(low < high)

       {

              while(low < high && pData[high] >= key)

                     high--;

 

              swap(pData[low], pData[high]);

 

              while(low < high && pData[low] <= key)

                     low++;

 

              swap(pData[low], pData[high]);

       }

 

       return low;

}

 

void swap(elem& a, elem& b)

{

       if(&a != &b)

       {

              a ^= b;

              b ^= a;

              a ^= b;

       }

 

}


//这个是原始的算法 

void qsort(elem* pData, int low, int high)

{

       if(low < high)

       {

              int pivot = partition(pData, low, high);

              qsort(pData, low, pivot - 1);

              qsort(pData, pivot + 1, high);

       }

}


//这个是第一次转化成递归以后的算法

void qsort2(elem* pData, int low, int high)

{

       Stack st;

 

       if(low < high)

       {

              int pivot = partition(pData, low, high);

              st.push(low);

              st.push(pivot - 1);

 

              st.push(pivot + 1);

              st.push(high);

             

              while(!st.empty())

              {

                     high = st.top();

                     st.pop();

                     low = st.top();

                     st.pop();

                    

                     pivot = partition(pData, low, high);

                    

                     if(low < high)

                     {

                            st.push(low);

                            st.push(pivot - 1);

 

                            st.push(pivot + 1);

                            st.push(high);

                     }

              }

       }

}


//这个是转化成递归以后改进的算法
void qsort3(elem* pData, int low, int high)

{

       Stack st;

       int tmp;

 

       if(low < high)

       {

              int pivot = partition(pData, low, high);

              st.push(low);

              st.push(pivot - 1);

 

              st.push(pivot + 1);

              st.push(high);

             

              while(!st.empty())

              {

                     high = st.top();

                     st.pop();

                     low = st.top();

                     st.pop();

                    

                     if(low < high)

                     {

                            pivot = partition(pData, low, high);

                           

                            tmp = pivot - 1;

                            if(low < tmp)

                            {

                                   st.push(low);

                                   st.push(tmp);

                            }

 

                            tmp = pivot + 1;

                            if(tmp < high)

                            {

                                   st.push(tmp);

                                   st.push(high);

                            }

                     }

              }

       }

}

 

//测试代码
int _tmain(int argc, _TCHAR* argv[])

{

      

       elem data[MAX_SIZE] = {12, 1, 13, 14, 67, 23, 12, 3, 90, 76};

       //qsort(data, 0, MAX_SIZE - 1);

       //qsort2(data, 0, MAX_SIZE - 1);

       qsort3(data, 0, MAX_SIZE - 1);

      

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

       {

              cout << data[i] << " ";

       }

 

       cout << endl;

      

       cin.get();

       return 0;

}

 

 

============================================================================

 

 

 

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

   假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一躺快速排序的算法是：

  1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；

  2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；

  3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；

  4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；

  5）、重复第3、4步，直到I=J；

  例如：待排序的数组A的值分别是：（初始关键数据X：=49）

                  A[1]    A[2]    A[3]    A[4]    A[5]     A[6]    A[7]： 

                    49       38      65      97      76      13       27

进行第一次交换后：  27       38      65      97      76      13       49

                  ( 按照算法的第三步从后面开始找

进行第二次交换后：  27       38      49      97      76      13       65

                 ( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时I：=3 )

进行第三次交换后：  27       38      13      97      76      49       65

( 按照算法的第五步将又一次执行算法的第三步从后开始找

进行第四次交换后：  27       38      13      49      76      97       65

( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时J：=4 )

     此时再执行第三不的时候就发现I=J，从而结束一躺快速排序，那么经过一躺快速排序之后的结果是：27       38      13      49      76      97       65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。

     快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：

 

 初始状态                       {49    38    65    97    76    13    27}   

进行一次快速排序之后划分为     {27    38    13}    49  {76    97    65}

分别对前后两部分进行快速排序   {13}   27   {38} 

                               结束        结束   {49   65}   76   {97}

                                                   49  {65}        结束

                                                       结束

                         图6   快速排序全过程

 

1）、设有N（假设N=10）个数，存放在S数组中；

2）、在S[1。。N]中任取一个元素作为比较基准，例如取T=S[1]，起目的就是在定出T应在排序结果中的位置K，这个K的位置在：S[1。。 K-1]<=S[K]<=S[K+1..N]，即在S[K]以前的数都小于S[K]，在S[K]以后的数都大于S[K]；

3）、利用分治思想（即大化小的策略）可进一步对S[1。。K-1]和S[K+1。。N]两组数据再进行快速排序直到分组对象只有一个数据为止。

如具体数据如下，那么第一躺快速排序的过程是：

数组下标： 1     2     3     4     5     6     7     8     9     10

          45    36    18    53    72    30    48    93    15     36

     I                                                                  J

（1）     36    36    18    53    72    30    48    93    15     45

 

（2）     36    36    18    45    72    30    48    93    15     53

 

（3）     36    36    18    15    72    30    48    93    45     53

 

（4）     36    36    18    15    45    30    48    93    72     53

 

（5）     36    36    18    15    30    45    48    93    72     53

通过一躺排序将45放到应该放的位置K，这里K=6，那么再对S[1。。5]和S[6。。10]分别进行快速排序。程序代码如下：

program kuaisu(input,output);
const n=10;
var
   s:array[1..10] of integer;
   k,l,m:integer;

procedure qsort(lx,rx:integer);
var
   I,j,t:integer;
Begin
   I:lx;j:rx;t:s[I];
   Repeat
      While (s[j]>t) and (j>I) do
         Begin
            k:=k+1;
            j:=j-1
         end;
   if I<j then
begin
   s[I]:=s[j];I:=I+1;l:=l+1;
   while (s[I]<t) and (I<j) do
       begin
          k:=k+1;
          I:=I+1
      End;
   If I<j then
begin
         S[j]:=s[I];j:=j-1;l:=l+1;
      End;
End;
Until I=j;
S[I]:=t;I:=I+1;j:=j-1;l:=l+1;
If lx<j then qsort(lx,j);
If I<rx then qsort(I,rx)
End;{过程qsort结束}

Begin
Writeln('input 10 integer num:');
For m:=1 to n do read(s[m]);
K:=0;l:=0;
Qsort(l,n);
Writeln('排序后结果是：')；
For m:=1 to n do write(s[m]:4)
End.


<49,两者交换，此时J:=6>

Arctton
关注
专栏目录
快速排序的递归非递归算法
weixin_44015485的博客
03-16 221
一.递归算法 public static void kuaipai(int[] a,int left,int right){ if(left>right){ return ; } int i=left,j=right; int tmp=a[left]; while(i<j){ while(tmp<=a[j]&&i<j){ j--; } while(tmp>=a[i]&i<j){ i++;
排序算法：快速排序（三种排序方式、递归和非递归）-快速排序算法
07-03
### 排序算法：快速排序（三种排序方式、递归和非递归） #### 快速排序概述 快速排序是一种高效的排序算法，由C. A. R. Hoare于1962年提出。它是基于分治策略的一种排序方法，通过选取一个基准值将待排序数组分为...
快速排序的非递归实现
weixin_34026276的博客
11-03 196
首先说明一下快速排序是对冒泡排序的改进。为什么这么说呢？想一下冒泡排序，它把序列分成了两部分，前半部分无序，后半部分升序排列，并且后半部分的数都大于前半部的数。 由此可得到快速排序和冒泡排序的一些共同点： 都要经历n趟排序 每趟排序要经历O(n)次比较 都是后半部分元素比前半部大 而不同之处就在于冒泡排序的交换操作发生相邻的元素之间，即一趟排序可以要经过多次交换操作；快速排序的交...
快速排序非递归实现
最新发布
guaiguaiyalj的博客
07-12 2054
快速排序的非递归方法实现。
快速排序(非递归)
weixin_49312527的博客
03-13 5028
快速排序非递归: 基本思想(默认升序):从数组中选取一个数来作为标准数,所有比这个数小的数全部放到其前面,比这个数字大的数放到其后面,此时这个标准数所处的位置就是其在有序数组中的位置,因此该标准数就不用在移动了,我们对其左右两边的数字继续执行之前的操作,这样每次都可以确定一个标准数在有序数组中的位置,直到所有数字都处在正确的位置为止,此时这个数组就为有序数组. 优化: 三数取中:我们取标准数的时候,取的数越居中则算法的时间复杂度越低越接近O(N*logN)效率越高,我们取的数越极端越接近最大或最小值则
快速排序(非递归算法)
martin_liang的专栏
11-16 801
// 快速排序_非递归.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include using namespace std; int myArray[] = {3,0,6,1,11,7,2,12,4,10,9,5,8}; void printArray(int *Arr
快排的非递归算法
weixin_30340617的博客
10-11 167
源地址：http://blog.sina.com.cn/s/blog_49458c270100nkm4.html http://hex.iteye.com/blog/777858 算法之非递归的快速排序 (2010-12-11 20:32:40) 转载▼ 标签： 算法 快速排序 ...
快速排序算法设计与分析总结 二叉树与树的转换前序、后序的递归、非递归算法，层次序的非递归算法的实现
06-23
快速排序算法设计与分析总结 二叉树与树的转换前序、后序的递归、非递归算法，层次序的非递归算法的实现 二叉树与树的转换前序、后序的递归、非递归算法，层次序的非递归算法的实现，应包含建树的实现 实现树与...
快速选择非递归与递归算法实现
09-26
快速选择算法是基于快速排序的一种高效选择算法，用于在未排序的数据集合中找到第k小（或第k大）的元素。它由C.A.R. Hoare在1960年提出，是线性时间复杂度的算法，在平均情况下表现优秀。在本主题中，我们将深入探讨...
C#，快速排序算法（Quick Sort）的非递归实现与数据可视化
03-20
常见的四种排序算法是：简单选择排序、冒泡排序、插入排序和快速排序。其中的快速排序的优势明显，一般使用递归方式实现，但遇到数据量大的情况则无法适用。实际工程中一般使用“非递归”方式实现。实际工程中一般...
[排序算法] 9. 归并排序递归与非递归实现及算法复杂度分析(分治算法、归并排序、复杂度分析)
01-06
文章目录1. 基本思想2. 代码实现2.1 递归实现2.2 优化—非递归实现3. 性能分析 1. 基本思想 在数列排序中，如果只有一个数，那么它本身就是有序的；如果只有两个数，那么一次... 快速排序多种递归、非递归实现及性能
快速排序的非递归算法.doc
05-26
用C实现了快速排序的非递归算法. int quickpass ( sqlist &R, int low, int high ) { ... } void quicksort ( sqlist &r, int low, int high ) { ... }
快速排序算法递归与非递归实现
Kylin Zhang的专栏
03-09 8145
快速排序是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归或者非递归进行，以此达到整个数据变成有序序列。快速排序的递归算法:   void qsort(int a[],int left,int right)  {       i
快速排序非递归算法
To be a better man
11-27 1818
#define MaxN 1000 typedef int keytype; void QUICKSORT(keytype K[],int n){ int i,j,left,right,pos=-1; int buf[MaxN][2];//数组buf用以保存下一趟快拍的起始和末尾位置 keytype temp; while(1){/*K[left]为分界元素*/ i = left; ...
快速排序————非递归实现
2201_75943325的博客
06-11 1241
大家有可能会想是不是因为递归非常的占用空间，我们都知道我们的局部变量是保存在栈上的我们的函数参数也是在栈上开辟的，所以说递归是不是会占用我们非常多的栈空间，同时呢我们的递归是一个非常深的一个操作，我们往往会因为一个函数递归出来的结果而去让这个函数重复调用多次去解决我们当前的问题，我们的快速排序非递归就是这样的方式，也包括之前的一个斐波那契数列使用递归去解决都是使用了栈；这样的方法在递归的深度不大的时候不会产生什么问题但是如果我们需要去处理的数据非常多，递归的深度非常深那么我们这个时候递归真的不会出现问题吗。
快速排序（非递归）
无云的专栏
01-03 1641
以下代码经测试，排序5000000（五千万）int型数据没有问题！ 第一个参数是数组首地址 第二个参数是数组元素个数 typedef struct _BUFF { int *LeftBuff; int *RightBuff; DWORD number;//有多少个 struct _BUFF *next; }BUFF; void QuickSort(i
非递归快速排序
zhufenghao
10-18 971
快速排序常常使用递归算法来实现，其运行时只使用lgN 的系统调用栈。如果想更清楚快速排序的运行过程，我们可以使用非递归的方法来实现快速排序。其方法最重要的部分是显式的使用一个栈来保存切分数组的下标，使用一个循环将出栈的子数组切分为二，并将结果重新入栈（这两个切分结果的入栈顺序不影响最后结果），直到结果都成为长度为一的子数组，此时排序完毕。 代码如下：// 非递归快速排序 public class
非递归快速排序算法
hanzy0823的专栏
09-25 849
昨天做人人网笔试题，其中一个就是快排非递归算法，当时考虑的不全面，下面发下正确答案。 先说递归算法 #include #include using namespace std; int partion(int*arr,int p,int r) { int key=arr[p];int i=p; for(int j=p+1;j { if(arr[j] { i++; int
c++实现非递归快速排序
06-07
以下是基本的非递归快速排序算法的步骤： 1. **分治策略**: 快速排序的核心思想是选取一个基准元素（pivot），将数组分为两部分，一部分所有元素都小于基准，另一部分所有元素都大于或等于基准。 2. **栈实现**: ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值