内部排序　快速排序

2011-06-23 01:40:47 201 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

ESP32-CAM与Thonny的完美搭配：从烧录到通信的完整流程本文详细介绍了如何将ESP32-CAM与Thonny IDE完美结合，从固件烧录到通信测试的完整流程。通过硬件连接、MicroPython固件烧录、Thonny环境配置以及摄像头功能开发等步骤，帮助开发者快速搭建高效的物联网开发环境，实现图像采集与无线通信功能。阅读详情

内部排序　
快速排序要用递归，应该是既费时又费空间的排序方法，那么为什么叫快速排序呢？

...全文

【保研经验】北科自动化到北大工学院作者：办公室某学长谢邀。。。作为拖延症晚期患者，希望能在我科开学前写完。先简单介绍一下我的保研过程，申请了清华叉院&amp;北大叉院大数据&amp;北大信科计算机夏令营,三者都没入营；申请了自所夏令营（自所来宣讲时未交简历，这是重大错误），给了第二批补录但没去；最终九推去了北大工学院。我的这次保研最终成功的经历可以说有一定运气成分，不具有普适性，但在前期准备过程中还是有经验可以分享的。 ... 阅读详情

尘缘udbwcso

C语言 70,039 成员 243,237 内容

+ 关注 + 加入社区

切换为时间正序

hackbuteer1 2011-06-23

打赏
举报

快速排序的的快速是相对其他的排序方法来讲是快速的，你可以看下书上的比较，无论时间复杂度还是空间复杂度，可以用递归实现，也可以不用递归来实现的。。。

赵4老师 2011-06-23

打赏
举报

c:\Microsoft SDK\src\crt\qsort.c

/***

*qsort.c - quicksort algorithm; qsort() library function for sorting arrays

*

*       Copyright (c) 1985-2001, Microsoft Corporation. All rights reserved.

*

*Purpose:

*       To implement the qsort() routine for sorting arrays.

*

*******************************************************************************/



#include <cruntime.h>

#include <stdlib.h>

#include <search.h>

#include <internal.h>



/* Always compile this module for speed, not size */

#pragma optimize("t", on)



/* prototypes for local routines */

static void __cdecl shortsort(char *lo, char *hi, size_t width,

                int (__cdecl *comp)(const void *, const void *));

static void __cdecl swap(char *p, char *q, size_t width);



/* this parameter defines the cutoff between using quick sort and

   insertion sort for arrays; arrays with lengths shorter or equal to the

   below value use insertion sort */



#define CUTOFF 8            /* testing shows that this is good value */



/***

*qsort(base, num, wid, comp) - quicksort function for sorting arrays

*

*Purpose:

*       quicksort the array of elements

*       side effects:  sorts in place

*       maximum array size is number of elements times size of elements,

*       but is limited by the virtual address space of the processor

*

*Entry:

*       char *base = pointer to base of array

*       size_t num  = number of elements in the array

*       size_t width = width in bytes of each array element

*       int (*comp)() = pointer to function returning analog of strcmp for

*               strings, but supplied by user for comparing the array elements.

*               it accepts 2 pointers to elements and returns neg if 1<2, 0 if

*               1=2, pos if 1>2.

*

*Exit:

*       returns void

*

*Exceptions:

*

*******************************************************************************/



/* sort the array between lo and hi (inclusive) */



#define STKSIZ (8*sizeof(void*) - 2)



void __cdecl qsort (

    void *base,

    size_t num,

    size_t width,

    int (__cdecl *comp)(const void *, const void *)

    )

{

    /* Note: the number of stack entries required is no more than

       1 + log2(num), so 30 is sufficient for any array */

    char *lo, *hi;              /* ends of sub-array currently sorting */

    char *mid;                  /* points to middle of subarray */

    char *loguy, *higuy;        /* traveling pointers for partition step */

    size_t size;                /* size of the sub-array */

    char *lostk[STKSIZ], *histk[STKSIZ];

    int stkptr;                 /* stack for saving sub-array to be processed */



    if (num < 2 || width == 0)

        return;                 /* nothing to do */



    stkptr = 0;                 /* initialize stack */



    lo = base;

    hi = (char *)base + width * (num-1);        /* initialize limits */



    /* this entry point is for pseudo-recursion calling: setting

       lo and hi and jumping to here is like recursion, but stkptr is

       preserved, locals aren't, so we preserve stuff on the stack */

recurse:



    size = (hi - lo) / width + 1;        /* number of el's to sort */



    /* below a certain size, it is faster to use a O(n^2) sorting method */

    if (size <= CUTOFF) {

        shortsort(lo, hi, width, comp);

    }

    else {

        /* First we pick a partitioning element.  The efficiency of the

           algorithm demands that we find one that is approximately the median

           of the values, but also that we select one fast.  We choose the

           median of the first, middle, and last elements, to avoid bad

           performance in the face of already sorted data, or data that is made

           up of multiple sorted runs appended together.  Testing shows that a

           median-of-three algorithm provides better performance than simply

           picking the middle element for the latter case. */



        mid = lo + (size / 2) * width;      /* find middle element */



        /* Sort the first, middle, last elements into order */

        if (comp(lo, mid) > 0) {

            swap(lo, mid, width);

        }

        if (comp(lo, hi) > 0) {

            swap(lo, hi, width);

        }

        if (comp(mid, hi) > 0) {

            swap(mid, hi, width);

        }



        /* We now wish to partition the array into three pieces, one consisting

           of elements <= partition element, one of elements equal to the

           partition element, and one of elements > than it.  This is done

           below; comments indicate conditions established at every step. */



        loguy = lo;

        higuy = hi;



        /* Note that higuy decreases and loguy increases on every iteration,

           so loop must terminate. */

        for (;;) {

            /* lo <= loguy < hi, lo < higuy <= hi,

               A[i] <= A[mid] for lo <= i <= loguy,

               A[i] > A[mid] for higuy <= i < hi,

               A[hi] >= A[mid] */



            /* The doubled loop is to avoid calling comp(mid,mid), since some

               existing comparison funcs don't work when passed the same

               value for both pointers. */



            if (mid > loguy) {

                do  {

                    loguy += width;

                } while (loguy < mid && comp(loguy, mid) <= 0);

            }

            if (mid <= loguy) {

                do  {

                    loguy += width;

                } while (loguy <= hi && comp(loguy, mid) <= 0);

            }



            /* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,

               either loguy > hi or A[loguy] > A[mid] */



            do  {

                higuy -= width;

            } while (higuy > mid && comp(higuy, mid) > 0);



            /* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,

               either higuy == lo or A[higuy] <= A[mid] */



            if (higuy < loguy)

                break;



            /* if loguy > hi or higuy == lo, then we would have exited, so

               A[loguy] > A[mid], A[higuy] <= A[mid],

               loguy <= hi, higuy > lo */



            swap(loguy, higuy, width);



            /* If the partition element was moved, follow it.  Only need

               to check for mid == higuy, since before the swap,

               A[loguy] > A[mid] implies loguy != mid. */



            if (mid == higuy)

                mid = loguy;



            /* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top

               of loop is re-established */

        }



        /*     A[i] <= A[mid] for lo <= i < loguy,

               A[i] > A[mid] for higuy < i < hi,

               A[hi] >= A[mid]

               higuy < loguy

           implying:

               higuy == loguy-1

               or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */



        /* Find adjacent elements equal to the partition element.  The

           doubled loop is to avoid calling comp(mid,mid), since some

           existing comparison funcs don't work when passed the same value

           for both pointers. */



        higuy += width;

        if (mid < higuy) {

            do  {

                higuy -= width;

            } while (higuy > mid && comp(higuy, mid) == 0);

        }

        if (mid >= higuy) {

            do  {

                higuy -= width;

            } while (higuy > lo && comp(higuy, mid) == 0);

        }



        /* OK, now we have the following:

              higuy < loguy

              lo <= higuy <= hi

              A[i]  <= A[mid] for lo <= i <= higuy

              A[i]  == A[mid] for higuy < i < loguy

              A[i]  >  A[mid] for loguy <= i < hi

              A[hi] >= A[mid] */



        /* We've finished the partition, now we want to sort the subarrays

           [lo, higuy] and [loguy, hi].

           We do the smaller one first to minimize stack usage.

           We only sort arrays of length 2 or more.*/



        if ( higuy - lo >= hi - loguy ) {

            if (lo < higuy) {

                lostk[stkptr] = lo;

                histk[stkptr] = higuy;

                ++stkptr;

            }                           /* save big recursion for later */



            if (loguy < hi) {

                lo = loguy;

                goto recurse;           /* do small recursion */

            }

        }

        else {

            if (loguy < hi) {

                lostk[stkptr] = loguy;

                histk[stkptr] = hi;

                ++stkptr;               /* save big recursion for later */

            }



            if (lo < higuy) {

                hi = higuy;

                goto recurse;           /* do small recursion */

            }

        }

    }



    /* We have sorted the array, except for any pending sorts on the stack.

       Check if there are any, and do them. */



    --stkptr;

    if (stkptr >= 0) {

        lo = lostk[stkptr];

        hi = histk[stkptr];

        goto recurse;           /* pop subarray from stack */

    }

    else

        return;                 /* all subarrays done */

}

...