java冒泡排序和快速排序的分析

说来惭愧，昨天面试的时候遇到快速排序的笔试题没答上来。搞java的长期接触的是业务方面的东西，特别是web方向的java，久而久之在学校里面学的最基本的一些东西给忘记了。网上搜索了这两种算法，基本都是当年书本的解释，个人不是很喜欢。现将自身强化后的解释描述出来，加强记忆，最近有面试的同志不妨看看。

1.冒泡排序

书本上的基本理念是左边元素跟右侧元素一个个对比，有更小的就交换。

我将此分解为：

a.将数组的最小元素放在左边；

b.对右边做递归；

这个比较简单，实现a的代码：

	// a.将数组的最小元素放在左边
	public static void bubbleBasic(int[] list) {
		// 基本前提
		if(list != null && list.length > 1) {

			// 从第二个元素开始对比
			for(int i=1;i<list.length;i++) {

				// 发现更小的就替换
				if(list[0] > list[i]) {
					int tmp = list[0];
					list[0] = list[i];
					list[i] = tmp;
				}
			}
		}
	}

a+b的代码：

	// a+b.完整的冒泡排序
	public static void bubbleSort(int[]list, int begin) {
		if(list != null && (list.length - begin) > 1) {
			for(int i=begin+1;i<list.length;i++) {
				if(list[begin] > list[i]) {
					int tmp = list[begin];
					list[begin] = list[i];
					list[i] = tmp;
				}
			}
			bubbleSort(list, begin +1);
		}
	}

当然有更简单的不用递归的方式的书本代码：

	// 书本的冒泡排序
	public static void bubbleBook(int[] list) {
		if(list != null && list.length > 1) {
			for(int i = 0 ; i < list.length-1 ; i++){
				for(int j = i+1 ; j < list.length ; j++){
					if(list[i] > list[j]) {
						int tmp = list[i];
						list[i] = list[j];
						list[j] = tmp;
					}
				}
			}
		}
	}

2.快速排序

书本上的基本理念是高位低位交叉对比，把数组分成两部分，左边都小于某个元素A，右边都大于A。

个人感觉这个描述很晕，其实是包含两部分，1.交叉对比，2.左边都小右边都大。我屏蔽掉第1点，把A固定成第一个元素，将此问题分解为：

a.把数组第一个元素放在某个位置，使得左边都小于它，右边都大于它；

b.对左右做递归；

对于a，不限制实现方式，相信绝大部分人都能做到。其实嘛算法就是要理解思想，实现方式是很多的，当然我这里也是用交叉对比来实现，我比较喜欢叫左右压缩对比。

实现a的代码：

	// a.把数组第一个元素放在某个位置，使得左边都小于它，右边都大于它
	public static void quickBasic(int[] list) {

		// 基本前提
		if(list != null && list.length > 1) {

			// 第一个元素当前位置
			int i_current = 0;

			// 得到左右边界
			int i_left = 0;
			int i_right = list.length -1;

			// 只要右边界还大于左边界，说明还有压缩空间
			while(i_left < i_right) {

				// 不断压缩右边界，直到没有压缩空间或者出现比第一个元素更小的元素
				while(i_current < i_right && list[i_current] < list[i_right]) {
					i_right--;
				}
				// 交换元素（即使没找到更小元素也交换，因为一直找不到的话i_right最终会等于i_current，这时候就是自身跟自身交换，就当冗余步骤好了）
				int tmp = list[i_current];
				list[i_current] = list[i_right];
				list[i_right] = tmp;
				// 第一个元素的位置已经改变
				i_current = i_right;

				//----------元素交换到右边后开始对左边压缩，跟上面的过程完全相反----------
				while(i_current > i_left && list[i_current] > list[i_left]) {
					i_left++;
				}
				tmp = list[i_current];
				list[i_current] = list[i_left];
				list[i_left] = tmp;
				i_current = i_left;

				//-----------返回while重复上面过程----------
			}

			//-----------程序运行到这里，已经没有压缩空间了，功能完成，这时候i_left = i_current = i_right
		}
	}

a+b的代码：

	// a+b.完整的快速排序
	public static void quickSort(int[] arr, int leftIndex, int rightIndex){
		if(arr != null && leftIndex < rightIndex) {

			// 备份一下初始化的左右边界，递归时候用到
			int _leftIndex = leftIndex;
			int _rightIndex = rightIndex;

			int currentIndex = leftIndex;
			while(leftIndex < rightIndex) {
				while(currentIndex < rightIndex && arr[currentIndex] < arr[rightIndex]) {
					rightIndex--;
				}
				int tmp = arr[currentIndex];
				arr[currentIndex] = arr[rightIndex];
				arr[rightIndex] = tmp;
				currentIndex = rightIndex;

				while(leftIndex < currentIndex && arr[leftIndex] < arr[currentIndex]) {
					leftIndex++;
				}
				tmp = arr[currentIndex];
				arr[currentIndex] = arr[leftIndex];
				arr[leftIndex] = tmp;
				currentIndex = leftIndex;
			}

			// 左右开始递归
			quickSort(arr, _leftIndex, currentIndex-1);
			quickSort(arr, currentIndex+1, _rightIndex);
		}
	}

快速排序暂时没发现不用递归能实现的方法。

上述方法的测试实例：

	public static void main(String[] args) {
		int[] list = new int[]{2,1,4,5,8,7,6,3,9,0};
		bubbleBasic(list);
		// 结果是0,2,4,5,8,7,6,3,9,1（打印方法就不写了）

		list = new int[]{2,1,4,5,8,7,6,3,9,0};
		bubbleSort(list, 0);
		// 结果是0,1,2,3,4,5,6,7,8,9

		list = new int[]{2,1,4,5,8,7,6,3,9,0};
		bubbleBook(list);
		// 结果是0,1,2,3,4,5,6,7,8,9

		list = new int[]{2,1,4,5,8,7,6,3,9,0};
		quickBasic(list);
		// 结果是0,1,2,5,8,7,6,3,9,4

		list = new int[]{2,1,4,5,8,7,6,3,9,0};
		quickSort(list, 0, list.length -1);
		// 结果是0,1,2,3,4,5,6,7,8,9
	}