代码没问题
我今天也遇到一样的问题
猜测是因为快排递归创建了很多栈，当数据量过大时就栈溢出
我的解决方法是自己也写了一个快速排序非递归的方法
但是实际耗费的时间仍然不如其他算法
最主要的是冒泡排序、选择排序、插入排序以及快速排序
1、冒泡排序
冒泡排序是一个比较简单的排序方法。在待排序的数列基本有序的情况下排序速度较快。若要排序的数有n个，则需要n-1轮排序，第j轮排序中，从第一个数开始，相邻两数比较，若不符合所要求的顺序，则交换两者的位置；直到第n+1-j个数为止，第一个数与第二个数比较，第二个数与第三个数比较，......，第n-j个与第n+1-j个比较，共比较n-1次。此时第n+1-j个位置上的数已经按要求排好，所以不参加以后的比较和交换操作。
例如：第一轮排序：第一个数与第二个数进行比较，若不符合要求的顺序，则交换两者的位置，否则继续进行二个数与第三个数比较......。直到完成第n-1个数与第n个数的比较。此时第n个位置上的数已经按要求排好，它不参与以后的比较和交换操作；第二轮排序：第一个数与第二个数进行比较，......直到完成第n-2个数与第n-1个数的比较；......第n-1轮排序：第一个数与第二个数进行比较，若符合所要求的顺序，则结束冒泡法排序；若不符合要求的顺序，则交换两者的位置，然后结束冒泡法排序。
共n-1轮排序处理，第j轮进行n-j次比较和至多n-j次交换。
从以上排序过程可以看出，较大的数像气泡一样向上冒，而较小的数往下沉，故称冒泡法。
public void bubbleSort(int a[])
{
int n = a.length
for(int i=0i<n-1i++)
{
for(int j=0j<n-i-1j++)
{
if(a[j] >a[j+1])
{
int temp = a[j]
a[j] = a[j + 1]
a[j + 1] = temp
}
}
}
}
2、选择排序
选择法的原理是先将第一个数与后面的每一个数依次比较,不断将将小的赋给第一个数,从而找出最小的,然后第二个数与后面的每一个数依次比较,从而找出第二小的,然后第三个数与后面的每一个数依次比较,从而找出第三小的.....直到找到最后一个数。
public void sort(int x[])
{
int n=x.length
int k,t
for(int i=0i<n-1i++)
{
k=i
for(int j=i+1j=nj++)
{
if(x[j]>x[k])k=j
if(k!=i)
{
t=x[i]
x[i]=x[k]
x[k]=t
}
}
}
}
3、插入排序
插入排序的原理是对数组中的第i个元素，认为它前面的i-1个已经排序好，然后将它插入到前面的i-1个元素中。插入排序对少量元素的排序较为有效.
public void sort(int obj[])
{
for(int j=1j<obj.lengthj++)
{
int key=obj[j]
int i=j-1
while(i>=0&&obj[i]>key)
{
obj[i+1]=obj[i]
i--
}
obj[i+1]=key
}
}
4、快速排序
快速排序是对冒泡排序的一种改进。它的基本思想是：通过一次排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此大道整个数据变成有序序列。
public void quickSort(int obj[],int low,int high)
{
int i=low
int j=high
int keyValue=obj[i]
while(i<j)
{
int temp=0
while(i<j&&obj[j]>=keyValue)
{
j=j-1
}
temp=obj[j]
obj[j]=obj[i]
obj[i]=temp
while(i<j&&obj[i]<=keyValue)
{
i=i+1
}
temp=obj[j]
obj[j]=ojb[i]
obj[i]=temp
}
obj[i]=keyValue
if(low<i-1)
{
quickSort(obj,low,i-1)
}
if(high>i+1)
{
quickSort(obj,i+1,high)
}
}
快速排序简单的说就是选择一个基准，将比起大的数放在一边，小的数放到另一边。对这个数的两边再递归上述方法。如本题
66 13 51 76 81 26 57 69 23，以66为基准，升序排序的话，比66小的放左边，比66大的放右边， 类似这种情况 13 。。。 66。。。69
具体快速排序的规则一般如下：
从右边开始查找比66小的数，找到的时候先等一下，再从左边开始找比66大的数，将这两个数借助66互换一下位置，继续这个过程直到两次查找过程碰头。
例子中：
66 13 51 76 81 26 57 69 23
从右边找到23比66小，互换
23 13 51 76 81 26 57 69 66
从左边找到76比66大，互换
23 13 51 66 81 26 57 69 76
继续从右边找到57比66小，互换
23 13 51 57 81 26 66 69 76
从左边查找，81比66大，互换
23 13 51 57 66 26 81 69 76
从右边开始查找26比66小，互换
23 13 51 57 26 66 81 69 76
从左边开始查找，发现已经跟右边查找碰头了，结束，第一堂排序结束
下面排序C语言的排序快速代码，参考一下
void sort(int *a, int left, int right)
{
if(left >= right)/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
{
return
}
int i = left
int j = right
int key = a[left]
while(i <j) /*控制在当组内寻找一遍*/
{
while(i <j &&key <= a[j])
/*而寻找结束的条件就是，1，找到一个小于或者大于key的数（大于或小于取决于你想升
序还是降序）2，没有符合条件1的，并且i与j的大小没有反转*/
{
j--/*向前寻找*/
}
a[i] = a[j]
/*找到一个这样的数后就把它赋给前面的被拿走的i的值（如果第一次循环且key是
a[left]，那么就是给key）*/
while(i <j &&key >= a[i])
/*这是i在当组内向前寻找，同上，不过注意与key的大小关系停止循环和上面相反，
因为排序思想是把数往两边扔，所以左右两边的数大小与key的关系相反*/
{
i++
}
a[j] = a[i]
}
a[i] = key/*当在当组内找完一遍以后就把中间数key回归*/
sort(a, left, i - 1)/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
sort(a, i + 1, right)/*用同样的方式对分出来的右边的小组进行同上的做法*/
/*当然最后可能会出现很多分左右，直到每一组的i = j 为止*/
}
