亲历快速排序算法,有感于程序的边界条件

        看数据结构的书,关于快速排序.算法倒是不难理解.  网上随便baidu了一个算法.  看起来似乎也像那么回事.

        然而原程序中只对10个数排序,并且排序前的数组的元素的值和顺序已经确定.  改成用java.util.Random产生随机数,来运行, 此时发现程序陷入死循环的几率非常大,即使没有死循环, 排序的结果也不对.

        于是改一改吧..  发现连界情况很是微妙. 也是本人愚钝,加上晚上思路不清,有些迷糊, 改了大约两个小时才改好. 

        现在随机数的上限和数组的大小均可以由参数指定 ,如果随机数的上限和数组的大小接近,可以考验程序在数组中有多个重复值时的运行情况;程序运行完后会打印出比较次数和交换次数.

       具体边界情况我都加上了注释.

      

import java.util.Random;

/**
 * 快速排序 通过一趟排序将要排序的数据分割成独立的两部分， 其中一部分的所有数据都比另外一部分的所有数据都要小，
 * 然后再按此方法对这两部分数据分别进行快速排序， 整个排序过程可以递归进行，以此达到整个数据变成有序序列。
 * 
 */
public class QuickSort {

	private static int compareTime = 0;
	private static int swapTime = 0;

	public static void main(String[] args) throws Exception {
		int size = 15;
		int sead = 20;

		if (args.length < 2) {

			System.out
					.println("下次请输入两个参数,第一个为数组的大小,第二个为随机数的上限,例如 java QuickSort 15 20");
			System.out.println("现在程序以size=15,sead=20以运行");
		} else {
			size = Integer.valueOf(args[0]);
			sead = Integer.valueOf(args[1]);
		}

		Random ran = new Random();
		int[] sort = new int[size];
		for (int i = 0; i < size; i++) {
			sort[i] = ran.nextInt(sead);
		}
		System.out.print("排序前的数组为");
		for (int i : sort) {
			System.out.print(i + " ");
		}

		quickSort(sort, 0, sort.length - 1);
		System.out.println();
		System.out.print("排序后的数组为");
		for (int i : sort) {
			System.out.print(i + " ");
		}
		System.out.println("\n程序比较次数-->"+compareTime+"\n程序交换次数-->"+swapTime);
	}

	/**
	 * 快速排序
	 * 
	 * @param sort 要排序的数组
	 * @param start 排序的开始座标
	 * @param end  排序的结束座标
	 */
	public static void quickSort(int[] sort, int start, int end) {

		// 此时说明已经排序完成
		if (end - start <= 0){
			compareTime++;
			return;
			
		}

		// 设置关键数据key为要排序数组的第一个元素，
		// 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小
		int key = sort[start];
		// 设置数组左边的索引，往右移动判断比key大的数
		int i = start + 1;   //注意此处要加上1
		// 设置数组右边的索引，往左移动判断比key小的数
		int j = end;
		// 如果左边索引比右边索引小，则还有数据没有排序
		while (i <= j) {   //等号用于当只有两个元素比如 0,6的排序,如果不加等号,排序后会交换0和6从而产生错误.
			while (sort[j] >= key && j > start) {    //这里如果去掉等号,程序即可能会产生while死循环
				j--;
				compareTime++;
			}
			while (sort[i] < key && i < end) {
				i++;
				compareTime++;
			}
			if (i < j) {
				int temp = sort[i];
				sort[i] = sort[j];
				sort[j] = temp;
				swapTime++;
			} else {
				break;   // 如果i>=j 说明j的位置即是key要交换的位置.交换后j前的元素均比key小,j后均比key大

			}

		}
		
		// 此时j停留在需要交换的位置,i的位置不定,可能比j大也可能和j相等
		// 将sort[start]和sort[j]交换

		sort[start] = sort[j];
		sort[j] = key;
		
		swapTime++;      
		// 递归调用
		if (j >= start && j <= end) {    //如果去掉这两个等号 对于48,37,35,36这种情况便无法正确排序
			swapTime+=2;
			quickSort(sort, start, j - 1);
			quickSort(sort, j + 1, end);
		}
	}
}