非递归的快速排序算法 （转）

最新推荐文章于 2022-04-21 17:49:36 发布
最新推荐文章于 2022-04-21 17:49:36 发布
阅读量125 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/yelang5012/archive/2013/04/03/2998425.html
版权

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

    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； 
                    }  
                } 
                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;

}

 

 

转载于:https://www.cnblogs.com/yelang5012/archive/2013/04/03/2998425.html

weixin_30421525
关注
快速排序的非递归算法.doc
05-26
用C实现了快速排序的非递归算法. int quickpass ( sqlist &R, int low, int high ) { ... } void quicksort ( sqlist &r, int low, int high ) { ... }
快排的非递归算法
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) 转载▼ 标签： 算法 快速排序 ...
非递归的快速排序算法
lionway
08-23 587
void qsort2(int a[],int low ,int high) {     stack st;     if (low         int mid =partition(a,low,high);         if (low             st.push(low);             st.push(mid-1);         }    
非递归快速排序算法
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
快速排序的非递归算法
起风了Samuel
07-09 2690
#include <stdio.h> typedef struct node { int min; int max; }Node; #define MaxSize 50 void sort(int a[], int min, int max) { int k = a[min]; int i = min; int j = max; int temp; Node Sta...
快速排序算法设计与分析总结 二叉树与树的转换前序、后序的递归、非递归算法，层次序的非递归算法的实现
06-23
快速排序算法设计与分析总结 二叉树与树的转换前序、后序的递归、非递归算法，层次序的非递归算法的实现 二叉树与树的转换前序、后序的递归、非递归算法，层次序的非递归算法的实现，应包含建树的实现 实现树与...
排序算法：快速排序（三种排序方式、递归和非递归）-快速排序算法
最新发布
07-03
### 排序算法：快速排序（三种排序方式、递归和非递归） #### 快速排序概述 快速排序是一种高效的排序算法，由C. A. R. Hoare于1962年提出。它是基于分治策略的一种排序方法，通过选取一个基准值将待排序数组分为...
快速选择非递归与递归算法实现
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. 基本思想 在数列排序中，如果只有一个数，那么它本身就是有序的；如果只有两个数，那么一次... 快速排序多种递归、非递归实现及性能
golang快速排序算法(非递归)
新之助的博客
02-10 1281
golang快速排序代码（非递归） 如果不使用递归的话需要借助队列或栈来实现排序，我这里使用栈的方式来实现，栈的实现如下： // 定义栈 type Stack struct { S []*Index } // 栈内元素结构 type Index struct { Left int Right int Key int } // 入栈 func (s *Stack) Push(...
快速排序的非递归算法实现
Much effort, much prosperity.
09-04 760
//快速排序算法的非递归实现，这种方法应该说是尾递归 //的非递归快速排序算法，它只把>1的右区间放入栈中， //减少了出栈入栈的次数。 template void NoQuickSort(vector& a, int s, int t){ vector> p(a.size()); p[0] = { s, t }; int k = 1, i = 0, j = 0; while (k ||
一个C语言实现不含递归的高效快速排序算法
风轻扬
10-04 3563
近来编写一个对性能要求很高的程序，要用到排序功能。要排序的数据类型有很多种，有整数、浮点数、各种结构（根据某个属性进行比较）等。如果调用libc的qsort()函数，调用比较函数的开销将会很大。因此就产生自己写一个排序函数的想法。由于数据类型的多样性，因此算法要有一定通用性。但我又不想用调用比较函数的开销，因此只能用宏来实现了。由于快速排序是目前最快的通用排序算法，因此当前选用快速排序算法。我选用
快速排序（四）—— 非递归排序
challenglistic的博客
03-13 4832
前面实现了快排的递归实现，并对其进行优化 但是递归需要在栈上为函数开辟空间，32位下，栈可使用的内存大小不超过2G，如果递归较深，依然可能会发生栈溢出 这个时候递归排序就不大适用，所以需要非递归出场 ...
[ 数据结构 -- 手撕排序算法第五篇 ] 快速排序 非递归实现
CSDN博客
04-21 7245
手撕排序算法系列之第五篇：快速排序（下） 从本篇文章开始，我会介绍并分析常见的几种排序，大致包括直接插入排序，冒泡排序，希尔排序，选择排序，堆排序，快速排序，归并排序等。 大家可以点击此链接阅读其他排序算法：排序算法_大合集（data-structure_Sort） 快速排序的递归实现方法全部总结在这篇：快速排序 ＜包含hoare法，挖坑法，前后指针法＞ 及其算法优化 这篇文章我们将一起讨论快速排序的非递归实现方法~ 1.快排非递归的实现思想 快排的非递归实现方法是利用了栈（栈 S...
【数据结构】快速排序非递归实现
Bitdancing的专栏
11-29 4534
常见的排序算法有以上八种，点击专栏就可以看其他排序算法，感兴趣的朋友们不妨点个收藏专栏。 ღ( ´･ᴗ･` )比心 OJ链接 快速排序的非递归实现可以使用 队列 和 栈进行。使用 队列 类似于 二叉树的层序遍历；使用 栈 类似于 二叉树的前序遍历。 本文采用栈进行非递归实现。 解题思想 根据栈先入后出的特点，用栈实现快速排序非递归分为以下过程： 右区间先入栈 左区间入栈，再取出栈顶 然后再右区间、左区间依次入栈，出左区间，直到栈为空。 图解过程 在一次单趟排序后，右区间、左区间依次入栈。 栈中数.
快速排序实现（递归+非递归）
蓝旭晨枫╮
04-06 5310
快速排序代码 首先是划分算法，假设每次都以第一个元素作为枢轴值，进行一趟划分： int Partition(int A[], int low, int high) { int pivot = A[low]; while (low < high) { while (low = pivot) --high;
手把手教你快速排序（非递归）
weixin_61857742的博客
03-17 2680
今天小编带大家学习快速排序的非递归方法，当然这篇博客是基于大家已经掌握了快排的递归方法的，如果还有不会的童鞋，可以看看下面这篇博客呦~：手把手教你快速排序(递归) 一.实现原理 首先我们需要一个栈。 我们知道，快速排序就是一个递归加分治的思想，在递归方法里，我们是把数列分成两部分，每个部分又分成两部分，直到不能再分为止。 所以我们可以用一个栈来存放数列两部分的头尾，排一次就让头尾出来，再把分好的两部分的头尾分别再入栈，再排再出，再入，直到不能再分成两部分为止。 原理图： 二.代码实...
快速排序 - 非递归实现总结
Growth Diary
01-21 550
秋招过去好久了，闲来无事，突然想到一个问题，就是他们总喜欢问快排，当然快排应该是比较简单的啦。当你实现的时候，他们大多会问，非递归的实现，这个就会难到一部分同学哈，我也是。现在总结一下。 快速排序递归实现： 先看一下，这个《数据结构教程》李春葆 第5版，提供的代码（语言是C/C++），递归版的（简练），原理就不解释了： void QuickSort(RecType R[]，int s，int t)...
汉诺塔非递归算法：快速排序数据结构实现
本文档主要介绍了汉诺塔问题的非递归解决方案，这是一个经典的计算机科学问题，涉及数据结构和算法中的排序算法。汉诺塔是一种涉及移动盘子的游戏，目标是将所有盘子从一个柱子（源）移动到另一个柱子（目标），在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值