Exception in thread "main" java.lang.StackOverflowError

[ffshao]

在使用快速排序对100万数据进行递归调用出现栈溢出，怎么解决？？？

[skgary]

出现这个异常说明递归的太多了，肯定是是代码有问题

[ffshao]

嗯，10多万次递归，能不能扩大栈的大小？

[ffshao]

我贴下代码，能不能帮我改成循环试试

public class Qsort {
	public static int []array;
	public void swap(int[] a, int i, int j){
		 int temp = a[i];
	        a[i] = a[j];
	        a[j] = temp;
	}
	 private int partition2(int[] array, int low, int high) {
	        int pivot = low;// 中枢元素位置，我们以第一个元素为中枢元素
	        // 退出条件这里只可能是 low = high
	        while (true) {
	            if (pivot != high) {// 如果中枢元素在低指针位置时，我们移动高指针
	                // 如果高指针元素小于中枢元素时，则与中枢元素交换
	                if (array[high]<array[pivot]) {
	                    swap(array, high, pivot);
	                    // 交换后中枢元素在高指针位置了
	                    pivot = high;
	                } else {// 如果未找到小于中枢元素，则高指针前移继续找
	                    high--;
	                }
	            } else {// 否则中枢元素在高指针位置
	                // 如果低指针元素大于中枢元素时，则与中枢元素交换
	                if (array[low]>array[pivot]) {
	                    swap(array, low, pivot);
	                    // 交换后中枢元素在低指针位置了
	                    pivot = low;
	                } else {// 如果未找到大于中枢元素，则低指针后移继续找
	                    low++;
	                }
	            }
	            if (low == high) {
	                break;
	            }
	        }
	        // 返回中枢元素所在位置，以便下次分区
	        return pivot;
	    }
 
	 public void qsort(int[] array,int low, int high) {
		 /*
	         * 如果分区中的低指针小于高指针时循环；如果low=higth说明数组只有一个元素，无需再处理； 如果low >
	         * higth，则说明上次枢纽元素的位置pivot就是low或者是higth，此种情况 下分区不存，也不需处理
	         */
	        if (low < high) {
	            // 对分区进行排序整理
	 
	            // int pivot = partition1(array, low, high);
	            int pivot = partition2(array, low, high);
	            // int pivot = partition3(array, low, high);
	 
	            /*
	             * 以pivot为边界，把数组分成三部分[low, pivot - 1]、[pivot]、[pivot + 1, high]
	             * 其中[pivot]为枢纽元素，不需处理，再对[low, pivot - 1]与[pivot + 1, high]
	             * 各自进行分区排序整理与进一步分区
	             */
	            qsort(array, low, pivot - 1);
	            qsort(array, pivot + 1, high);
	        }
	    }
	public static void main(String[] args) {
		Array a=new Array();
		array=a.productArray();
		Qsort q=new Qsort();
		int length=array.length-1;
		long startTime = System.currentTimeMillis();
		q.qsort(array, 0, length);
		long endTime = System.currentTimeMillis();
		System.out.println("排序时间："+(endTime-startTime)+"ms");
	}

}

[skgary]

你这个代码，递归调用的时候连退出条件都没有，当然要stack overflow了。

[枫醉秋]

你的递归成无限递归了，肯定内存溢出了

[tony4geek]

内存溢出。找找跳出的条件。

[ffshao]

扩大堆栈就解决了，不过，哪位大神能把快速排序从递归改成循环

[youzi05]

不递归就得使用栈,这里提供一段代码参考, 太麻烦,没有测试, 应该可以运行,,

// 类属性
Stack<Integer> st = new Stack<Integer>();

// 主方法调用qsort
st.push(length);
st.push(0);
while( !st.empty() ){
	 qsort(array, st.pop(), st.pop());
}

// qsort改递归为压栈
public void qsort(int[] array,int low, int high) {
    if (low < high) {
    	int pivot = partition2(array, low, high);
    	st.push(high);
    	st.push(pivot+1);
    	st.push(pivot-1);
    	st.push(low);
    }
}

[开不了口1990]

以前用递归实现的，写得不好，可以参考一下

public static void quickSort(Integer[] arr,int start, int end) {
		int flag = arr[start];
		int position = start;
		for(int i=start+1; i<end; i++){
			if(flag >= arr[i]) {
				move(arr,position++,i);
			}
		}
		
		if(position - start > 2)
			quickSort(arr, start, position);
		
		if(end - position > 2)
			quickSort(arr, position+1, end);
	}
	
	private static void move(Integer[] arr, int a, int b) {
		for(int i=b; i>a; i--){
			swap(arr, i, i-1);
		}
	}
	
	private static void swap(Integer[] arr, int a, int b) {
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

[youzi05]

引用 10 楼 feifeishao 的回复:

能不能改成循环的，我像不利用栈，大量数据下使用栈容易溢出报错

额,需要模拟递归就得用栈, 因为需要记录信息啊, 记录下起始地址和结束地址. 这个栈是在堆上申请的空间, 理论上, 你的硬盘剩余多大空间,或者说你的虚拟存储有多大, 堆就有多大, lz有多大的数据量,能把整个虚拟存储耗完.....

[ffshao]

能不能改成循环的，我像不利用栈，大量数据下使用栈容易溢出报错

[ffshao]

有没有利用for循环或者while循环的实现的快速排序？？？

[youzi05]

引用 12 楼 feifeishao 的回复:

有没有利用for循环或者while循环的实现的快速排序？？？

额 假设排过一次后, 中点在i处, 那么下一次就该排序 0到i-1 和 i+1到最后两段数据了, 很明显会出现重复的任务 重复的任务可以使用递归和循环实现, 所以 我们可以假设可以使用循环实现, 但是接下来一个问题就是存储 起始地址和末尾地址, 那么很明显存取得有顺序, 假设 a1 < a2 < a3 那么在排a1到a3之前, 不能排a1到a2-1 和 a2+1到a3 额 如果好好想想, 其实使用栈或者队列应该都是可以的, 也就是说可以循环, 但是由于需要存储一些有序信息, 所以需要使用到栈或者[b]队列[/b, 另外由于循环没有递归直观, 所以一般都是使用递归,