#include "iostream.h" void order_1(int[],int,int); void main() { int len; int a[]={12,2,13,111,14,15,1,2}; len=sizeof(a)/sizeof(int); order_1(a,0,len-1); cout<<endl<<"result is:"; for(int k=0;k<len;k++) { cout<<a[k]<<" "; } } void order_1(int a[],int left,int right) //快速排序法 { int mid,l,r,temp; l=left; r=right; mid=a[(left+right)/2]; //取中值作为分界线

while(l<r) { while(a[l]<mid) ++l; while(a[r]>mid) --r;

if(l>=r) break;

temp=a[l]; a[l]=a[r]; a[r]=temp; if(l!=mid) --r; if(r!=mid) ++l; } if(l==r) l++; if(left<r) order_1(a,left,l-1); if(l<right) order_1(a,r+1,right); }

当

int a[]={12,2,13,111,14,15,1,2};

改成这些的时候

int a[]={1,1,1,1,1,1,1,1};

会出现错误 overflow stacks?

why????

// try it
#include &lt;iostream&gt;
using namespace std;

class QuickSorter
{
private:
    int * a;
    int size;
    void quicksort(int lo, int hi)
    {
        int i=lo, j=hi;
        int x=a[(lo+hi)/2];

        //  Aufteilung
        while (i&lt;=j)
        {   
            while(a[i]&lt;x)
                i++;
            while(a[j]&gt;x)
                j--;
            if(i&lt;=j)
            {
                exchange(i, j);
                i++;
                j--;
            }
        }

        // Rekursion
        if(lo&lt;j)
            quicksort(lo, j);
        if(i&lt;hi)
            quicksort(i, hi);
    }
    void exchange(int i, int j)
    {
        int t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
public:
    QuickSorter(int * pi, int s)
    {
        size = s;
        a = new int[size];
        memcpy(a, pi, size * sizeof(int));
    }
    ~QuickSorter()
    {
        if(a)
        {
            delete [] a;
            size = 0;
        }
    }
    void sort()
    {
        quicksort(0, size - 1);
    }
    void display()
    {
        for(int i = 0; i&lt;size; i++)
            cout&lt;&lt;a[i]&lt;&lt;" ";
    }
};
int main()
{
    int a[] = {1,1,2,1,-6,1,1,1,1,1};
    QuickSorter myQuickSorter(a, sizeof(a)/sizeof(int));
    myQuickSorter.sort();
    myQuickSorter.display();

    return 0;
}

// viel Spass