快速排序（非递归）

最新推荐文章于 2024-07-12 22:29:04 发布
最新推荐文章于 2024-07-12 22:29:04 发布
阅读量1.6k 收藏 3
点赞数 1
分类专栏： C 文章标签： null struct 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kevinshq/article/details/7172551
版权

以下代码经测试，排序5000000（五千万）int型数据没有问题！

第一个参数是数组首地址
第二个参数是数组元素个数 

typedef struct _BUFF {
    int *LeftBuff;
    int *RightBuff;
    DWORD number;//有多少个
    struct _BUFF *next;
}BUFF;
void QuickSort(int * const arr, DWORD number)//快速排序
{
    int tmp;
    int key;
    DWORD left, right;
    DWORD tmpLeft, tmpRight;
    BUFF *p = NULL;
    BUFF buff = {NULL, NULL, 0, NULL};
    buff.LeftBuff = (int *)malloc(1024*1024*sizeof (int));
    buff.RightBuff = (int *)malloc(1024*1024*sizeof (int));
    if ((NULL == buff.LeftBuff) || (NULL == buff.LeftBuff))
    {
        free(buff.LeftBuff);
        free(buff.LeftBuff);
        printf("分配缓存出错！\n");
        return;
    }
    buff.LeftBuff[buff.number] = 0;
    buff.RightBuff[buff.number] = number-1;
    buff.number++;
    p = &buff;
    while (buff.number/* && (NULL == buff.next)*/)
    {
        tmpLeft = p->LeftBuff[p->number-1];
        tmpRight = p->RightBuff[p->number-1];
        left = tmpLeft;
        right = tmpRight;
        key = arr[left++];
        do
        {
            while ((arr[left] < key) && (left < tmpRight))
            {
                left++;
            }
            while ((arr[right] >= key) && (right > tmpLeft))
            {
                right--;
            }
            if (left < right)
            {
                tmp = arr[left];
                arr[left] = arr[right];
                arr[right] = tmp;
            }
        }
        while (left < right);
        tmp = arr[right];
        arr[right] = arr[tmpLeft];
        arr[tmpLeft] = tmp;

        if (p->number >= 1024*1024-1)
        {
            p->next = (BUFF *)malloc(sizeof (BUFF));
            if (NULL != p->next)
            {
                p = p->next;
                p->LeftBuff = (int *)malloc(1024*1024*sizeof (int));
                p->RightBuff = (int *)malloc(1024*1024*sizeof (int));
                p->number = 0;
                p->next = NULL;
            }
            if ((0 != p->number) || (NULL == p->LeftBuff) || (NULL == p->RightBuff))
            {
                printf("分配缓存出错！\n");
                while (NULL != buff.next)
                {
                    p = buff.next;
                    do
                    {
                        p = p->next;
                    }
                    while (NULL != p->next);
                    free(p);
                }
                getch();
                return;
            }
        }
        else
        {
            p->number--;
        }

        if (tmpLeft+1 < right)
        {
            p->LeftBuff[p->number] = tmpLeft;
            p->RightBuff[p->number] = right-1;
            p->number++;
        }
        if (tmpRight > left)
        {
            p->LeftBuff[p->number] = left;
            p->RightBuff[p->number] = tmpRight;
            p->number++;
        }
        if ((0 == p->number) && (NULL != buff.next))
        {
            p = &buff;
            while (NULL == p->next->next)
            {
                p = p->next;
            }
            free(p->next);
            p->next = NULL;
        }
    }
}


测试代码：


#include <stdio.h>
#include <conio.h>
#include <windows.h>

typedef struct _BUFF {
    int *LeftBuff;
    int *RightBuff;
    DWORD number;//有多少个
    struct _BUFF *next;
}BUFF;

void QuickSort(int * const arr, DWORD number);//快速排序
void ExamineArr(const int * const arr, DWORD number);//检查排序结果

int main(int argc, char *argv[])
{
    DWORD StartTime, EndTime;
    DWORD i;
    DWORD num = 50000000;
    int *arr = NULL;
    arr = (int *)malloc(num * sizeof (int));
    if (NULL == arr)
    {
        free(arr);
        printf("内存分配失败，程序退出！\n");
        getch();
        return -1;
    }

    StartTime = GetTickCount();
    for (i=0; i<num; i++)
    {
        *(arr+i) = rand();
    }
    EndTime = GetTickCount();
    printf("生成%u个随机数耗时：%ums\n", num, EndTime - StartTime);
    
    StartTime = GetTickCount();
    QuickSort(arr, num);
    EndTime = GetTickCount();
    printf("快速排序耗时：%ums\n", EndTime - StartTime);
    ExamineArr(arr, num);//检查排序结果

    free(arr);
    getch();
    return 0;
}

void QuickSort(int * const arr, DWORD number)//快速排序
{
    int tmp;
    int key;
    DWORD left, right;
    DWORD tmpLeft, tmpRight;
    BUFF *p = NULL;
    BUFF buff = {NULL, NULL, 0, NULL};
    buff.LeftBuff = (int *)malloc(1024*1024*sizeof (int));
    buff.RightBuff = (int *)malloc(1024*1024*sizeof (int));
    if ((NULL == buff.LeftBuff) || (NULL == buff.LeftBuff))
    {
        free(buff.LeftBuff);
        free(buff.LeftBuff);
        printf("分配缓存出错！\n");
        return;
    }
    buff.LeftBuff[buff.number] = 0;
    buff.RightBuff[buff.number] = number-1;
    buff.number++;
    p = &buff;
    while (buff.number/* && (NULL == buff.next)*/)
    {
        tmpLeft = p->LeftBuff[p->number-1];
        tmpRight = p->RightBuff[p->number-1];
        left = tmpLeft;
        right = tmpRight;
        key = arr[left++];
        do
        {
            while ((arr[left] < key) && (left < tmpRight))
            {
                left++;
            }
            while ((arr[right] >= key) && (right > tmpLeft))
            {
                right--;
            }
            if (left < right)
            {
                tmp = arr[left];
                arr[left] = arr[right];
                arr[right] = tmp;
            }
        }
        while (left < right);
        tmp = arr[right];
        arr[right] = arr[tmpLeft];
        arr[tmpLeft] = tmp;

        if (p->number >= 1024*1024-1)
        {
            p->next = (BUFF *)malloc(sizeof (BUFF));
            if (NULL != p->next)
            {
                p = p->next;
                p->LeftBuff = (int *)malloc(1024*1024*sizeof (int));
                p->RightBuff = (int *)malloc(1024*1024*sizeof (int));
                p->number = 0;
                p->next = NULL;
            }
            if ((0 != p->number) || (NULL == p->LeftBuff) || (NULL == p->RightBuff))
            {
                printf("分配缓存出错！\n");
                while (NULL != buff.next)
                {
                    p = buff.next;
                    do
                    {
                        p = p->next;
                    }
                    while (NULL != p->next);
                    free(p);
                }
                getch();
                return;
            }
        }
        else
        {
            p->number--;
        }

        if (tmpLeft+1 < right)
        {
            p->LeftBuff[p->number] = tmpLeft;
            p->RightBuff[p->number] = right-1;
            p->number++;
        }
        if (tmpRight > left)
        {
            p->LeftBuff[p->number] = left;
            p->RightBuff[p->number] = tmpRight;
            p->number++;
        }
        if ((0 == p->number) && (NULL != buff.next))
        {
            p = &buff;
            while (NULL == p->next->next)
            {
                p = p->next;
            }
            free(p->next);
            p->next = NULL;
        }
    }
}

void ExamineArr(const int * const arr, DWORD number)
{
    DWORD i=0, j=1;
    if (number <2)
    {
        return;
    }
    for (; j<number; i++,j++)
    {
        if (arr[i] > arr[j])
        {
            printf("第%u个数大于第%u个数！\n", i, j);
            return;
        }
    }
}


快速排序非递归用队列实现c++
qq_30316567的博客
12-26 3208
快速排序非递归用队列实现 第一次写博客，写的不是太好，但不是我邢标吹牛耐心看保证你会！！！！ ① 先了解快排原理： 假设有一个数组 6 2 1 7 9 3 4 5 8 10 1.先找一个数作为参考对象，为了方便，就以数组的第一个元素作为参考对象，所以6就是参考对象。 2.设立两个哨兵i，j，指向参考对象的后一个元素 ，j指向即将排序序列的最后一个元素（如果不太理解的话可以参考下面的图） 好！...
快速排序非递归实现及递归实现性能比较----Java
蜗牛
03-23 1902
快速排序非递归实现及递归实现性能比较 快排是常用算法，本文不再赘述快排原理。本文主要研究快速排序非递归实现及递归实现在排序900万个int整数时的性能差异。 一 代码 package common.algorithm; import java.util.Random; import java.util.Stack; /** * 快速排序不同版本 * * @descript...
快速排序 --- 非递归实现
11-04
快速排序 非递归实现方式的完整源代码和测试结果。
非递归快速排序
zhufenghao
10-18 1012
快速排序常常使用递归算法来实现，其运行时只使用lgN 的系统调用栈。如果想更清楚快速排序的运行过程，我们可以使用非递归的方法来实现快速排序。其方法最重要的部分是显式的使用一个栈来保存切分数组的下标，使用一个循环将出栈的子数组切分为二，并将结果重新入栈（这两个切分结果的入栈顺序不影响最后结果），直到结果都成为长度为一的子数组，此时排序完毕。 代码如下：// 非递归快速排序 public class
快速排序————非递归实现
2201_75943325的博客
06-11 1425
大家有可能会想是不是因为递归非常的占用空间，我们都知道我们的局部变量是保存在栈上的我们的函数参数也是在栈上开辟的，所以说递归是不是会占用我们非常多的栈空间，同时呢我们的递归是一个非常深的一个操作，我们往往会因为一个函数递归出来的结果而去让这个函数重复调用多次去解决我们当前的问题，我们的快速排序非递归就是这样的方式，也包括之前的一个斐波那契数列使用递归去解决都是使用了栈；这样的方法在递归的深度不大的时候不会产生什么问题但是如果我们需要去处理的数据非常多，递归的深度非常深那么我们这个时候递归真的不会出现问题吗。
快速排序(非递归)
weixin_49312527的博客
03-13 5391
快速排序非递归: 基本思想(默认升序):从数组中选取一个数来作为标准数,所有比这个数小的数全部放到其前面,比这个数字大的数放到其后面,此时这个标准数所处的位置就是其在有序数组中的位置,因此该标准数就不用在移动了,我们对其左右两边的数字继续执行之前的操作,这样每次都可以确定一个标准数在有序数组中的位置,直到所有数字都处在正确的位置为止,此时这个数组就为有序数组. 优化: 三数取中:我们取标准数的时候,取的数越居中则算法的时间复杂度越低越接近O(N*logN)效率越高,我们取的数越极端越接近最大或最小值则
非递归的快速排序、归并排序
LiXingyue
09-04 401
本文主要内容： 1.非递归的快速排序 2.归并排序 3.非递归的归并排序 4.简单的排序总结 5.简单的排序实验 - 快速排序 Arrays.sort（基本数据类型的数组）,基本使用快排 优化点：（1）基准值的选择 （2）做partition过程中是否考虑基准值相等的问题 （3）快排更适合对数据量比较大的场景使用，往往数据量比较小时，使用插入排序 如何用非递归实现快速排序？ 自己使用栈记录待排...
C++快速排序的递归和非递归实现
weixin_44501989的博客
05-26 252
#include<iostream> #include "stdafx.h" #include <iostream> #include <ctime> #include <stack> using namespace std; int PartSort(int* pArray, int nLeft, int nRight) { int nKey = pArray[nLeft]; while (nLeft < nRight) {
[算法入门]快速排序非递归方法（Java实现），大家一起来找茬啊～
haolvshiqi的专栏
01-09 4586
基础总结一下，快速排序的步骤： 1、找到一个key值（就是数组第一个值），先从右到左找，找到一个比它小的值，记录下标。 2、然后从左往右找，找到一个比它大的值，记录下标。 3、交换找到的两个数字。 4、继续，直到从右往左找的数字和从左往右找的数字下标重合。交换key值和重合值。 5、这时key值左边就全是比它小的数字，key值右边全是比它大的数字。 6、以key值为基准，将数组分为两段，
快速排序的非递归实现
hggjgff的博客
11-05 228
分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.youkuaiyun.com/jiangjunshow也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 华夏35度Data M
快排的非递归算法
weixin_30340617的博客
10-11 205
源地址：http://blog.sina.com.cn/s/blog_49458c270100nkm4.html http://hex.iteye.com/blog/777858 算法之非递归的快速排序 (2010-12-11 20:32:40) 转载▼ 标签： 算法 快速排序 ...
快速排序非递归实现
最新发布
guaiguaiyalj的博客
07-12 2446
快速排序的非递归方法实现。
快速排序非递归算法
To be a better man
11-27 1862
#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; ...
非递归的快速排序
sicofield的专栏
05-08 6511
一般的快速排序是用递归来实现的，如何将快速排序改写为迭代而不是递归？由于递归函数需要保护现场（在栈中），所以可以认为的构建一个栈。 由于快速排序中处理排序是partition子函数（过程），然后将划分范围减小，来实现排序。所以要保存的是待继续排序（划分）的边界。这样的一个栈很容易自我构建。 #include using namespace std; //划分子函数 int partition
快速排序非递归
beststudent_的博客
05-06 141
import java.util.Arrays; import java.util.Random; //用栈进行快排非递归 public class Test{ public static int partion(int[] array, int low, int high) { int tmp = array[low]; while (low < high) { while (( low ...
c++ 快速排序非递归
08-17
你可以使用迭代实现快速排序的非递归版本。下面是一个示例代码： ```cpp #include <iostream> #include <stack> using namespace std; // 交换两个元素的值 void swap(int& a, int& b) { int temp = a; a = b; b = temp; } // 快速排序非递归实现 void quickSort(int arr[], int low, int high) { stack<int> stk; stk.push(low); stk.push(high); while (!stk.empty()) { high = stk.top(); stk.pop(); low = stk.top(); stk.pop(); int pivot = arr[high]; int i = low - 1; for (int j = low; j <= high - 1; j++) { if (arr[j] < pivot) { i++; swap(arr[i], arr[j]); } } swap(arr[i + 1], arr[high]); if (i + 1 < high) { stk.push(i + 2); stk.push(high); } if (i + 1 > low) { stk.push(low); stk.push(i); } } } // 打印数组 void printArray(int arr[], int size) { for (int i = 0; i < size; i++) { cout << arr[i] << " "; } cout << endl; } int main() { int arr[] = {5, 2, 8, 12, 3, 7}; int size = sizeof(arr) / sizeof(arr[0]); cout << "原始数组: "; printArray(arr, size); quickSort(arr, 0, size - 1); cout << "排序后数组: "; printArray(arr, size); return 0; } ``` 这段代码使用了一个栈来模拟递归调用的过程。在每一次循环中，取出栈中保存的low和high值，然后进行快速排序的划分操作。如果划分后的左半部分和右半部分的长度大于1，就将新的low和high值压入栈中，以便后续继续排序。通过循环不断处理栈中的任务，直到栈为空，即完成了整个排序过程。 注意，这段代码只是一个示例，实际使用时可能需要根据具体情况进行适当的修改和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值