Re0:Java编程系列-1 我想写个冒泡排序

Re0:Java编程系列

作者参加校招，在复习Java的同时，决定开一打系列博客。复习的同时，作者希望能留下材料，方便也服务一些新入门的小伙伴。

本系列文章从基础入手，由简单的功能函数开始，再扩展为类，包，项目结构等等。进一步延伸至Java编程的核心思想，封装，继承，多态。

文章从面向功能编程方法开始过渡，手写代码的同时，逐渐向小伙伴揭示Java的编程思想和面向对象编程方法。

---

提示：Java写代码前，需要Java环境和IDE集成环境，作者不赘述，希望小伙伴们提前准备好。

---

前言

有一天，我心血来潮，想写个冒泡排序。
但是，面对Java庞大的IDE，我不知所措。
也许，我应该看看，冒泡排序的算法，细细思考，冒泡排序的代码写法。
伴着夜色，我哆嗦着爬上书桌，开始敲码。

---

一、冒泡排序？

引导：冒泡排序是一种算法，从过程来分析，犹如人类沉入水底。在人下降的过程中，不断会有气泡上升，顾明冒泡排序。

冒泡排序需要注意三点：

• 算法是按照什么顺序执行的？
• 排好的元素是在数组前，还是在数组后？
• 未排好的元素是如何控制，从而达成有序数组？

当我们想清楚，这三个问题后，冒泡排序便可以顺手拈来了。以后，无论语言换成什么，我们都可以迅速完成冒泡排序算法。

现在，花1分钟，思考以上的问题。

二、开始敲码！

1.函数编写

首先，我们弄好一个函数的模子。设定好参数和返回值，遵守函数的命名风格，“首单词字母小写，其余单词字母大写”。

代码如下（示例）：

	public int[] bubbleSort(int[] array) {
		//Todo
		return array;
	}

然后，我们理清楚思路，对问题逐一分析，并且构思代码。

1. 函数顺序由小下标到达大下标，按0 -> length-1顺序执行。
2. 每一遍排序执行结束，都在数组的最后一个元素，那么最后一个元素一定是已经排好的。
3. 未排好的元素应逐渐变少，排好的元素将缓慢增多。当数组第一个元素后的所有元素排好时，整个排序便完成了。

我们不难发现，每一次排序完成，数组中最大的元素到了数组的末尾。而且每一次排序中，我们至少能排好一个元素。

代码如下（示例）：

	public int[] bubbleSort(int[] array) {
		//交换,临时变量
		int temp = 0;
		//外层循环，意味着排序次数
		for (int i = 0; i < array.length - 1; i++) {
			//内层循环，意味着比较次数
			for (int j = 0; j < array.length - i - 1; j++) {
				//前一个元素大于后一个元素时，置换
				if(array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		return array;
	}

2.优化函数

具体函数编程完成后，我们发现，有些情况下，尤其是在数组本身已经相当有序时，我们的置换次数几乎没有。但是，函数还是傻呆呆一遍遍的排序，一遍遍的比较。

那么，我们是不是可以通过一种机制，控制排序次数呢？

仔细想想，为什么不可以直接控制比较次数？

当一轮排序中，数组中的所有元素都没发生变化，意味着排序已经完成。

为了直观感受，各冒泡函数版本的优劣。我们来写一个BubbleSort类，并通过类的成员函数，控制各版本的冒泡函数。

同时，新增两个成员变量，用于冒泡函数的控制机制。

代码如下（示例）：

public class BubbleSort {
	//记录量，排序执行次数
	public int total;
	//判断量，判断排序情况
	public boolean isOK;
	
	public int[] bubbleSort1(int[] array) {
		//Todo
		return array;
	}
	public int[] bubbleSort2(int[] array) {
		//Todo
		return array;
	}
	public int[] bubbleSort3(int[] array) {
		//Todo
		return array;
	}
}

我们给bubbleSort1新增一个total，记录排序次数。

我们给bubbleSort2新增一个total，记录排序次数。并且增加一个判断机制isOK，当判断数组已经有序时，结束。

我们给bubbleSort3新增一个total，记录排序次数。并且增加一个判断机制isOK，当判断数组已经有序时，结束。在函数执行前，我们判断数组的边界合法时，才执行函数主体。

代码如下（示例）：

public class BubbleSort {

	public int total;
	public boolean isOK;
	
	public int[] bubbleSort1(int[] array) {
		int temp = 0;
		total = 0;
		for (int i = 0; i < array.length - 1; i++) {
			for (int j = 0; j < array.length - i - 1; j++) {
				if(array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
			//所有比较完成后，排序次数加一
			total++;
		}
		return array;
	}
	public int[] bubbleSort2(int[] array) {
		int temp = 0;
		total = 0;
		for (int i = 0; i < array.length - 1; i++) {
			//假设数组有序，isOK为true
			isOK = true;
			for (int j = 0; j < array.length - i - 1; j++) {
				if(array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
					//置换发生时，意味着排序未完成
					isOK = false;
				}
			}
			total++;
			//判断，数组情况
			if (isOK) {
				break;
			}
		}
		return array;
	}
	public int[] bubbleSort3(int[] array) {
		//当数组为空时，直接返回空
		if (array == null || array.length < 1) {
			return null;
		} 
		//bubblesort2
		...
	}
}

3.启动函数

经过编码和优化，我们有了三个排序函数，是时候验证一下，我们的思路了。

在Java编程中，一切事物均是对象。而对象，恰恰便是类的实例。我们在写的成员变量和成员函数，都是在类中的。

犹如函数的使用需要参数一般，类的使用需要对象。

我们需要将类，实例化成对象后，通过对象，才能调用类的函数。

方便测试，我们将main函数写在BubbleSort类中，直接运行。

代码如下（示例）：

public class BubbleSort {
	//记录量，排序执行次数
	public int total;
	//判断量，判断排序情况
	public boolean isOK;
	
	public int[] bubbleSort1(int[] array) {
		//Todo
		return array;
	}
	public int[] bubbleSort2(int[] array) {
		//Todo
		return array;
	}
	public int[] bubbleSort3(int[] array) {
		//Todo
		return array;
	}

	public static void main(String[] args) {
		//对象初始化
		BubbleSort test = new BubbleSort();
		int[] array1_1 = {1,5,4,8,3,30,11};
		int[] array1_2 = {1,2,3,6,9,30,15};
		int[] array2_1 = {1,5,4,8,3,30,11};
		int[] array2_2 = {1,2,3,6,9,30,15};
		int[] array;
		//格式化输出
		System.out.println("原数组array1：" + Arrays.toString(array1_1));
		System.out.println("原数组array2：" + Arrays.toString(array1_2));
		
		array = test.bubbleSort1(array1_1);
		System.out.println("Sort1-1：" + Arrays.toString(array));
		System.out.println("执行次数：" + test.total);
		array = test.bubbleSort1(array1_2);
		System.out.println("Sort1-2：" + Arrays.toString(array));
		System.out.println("执行次数：" + test.total);
		
		array = test.bubbleSort2(array2_1);
		System.out.println("Sort2-1：" + Arrays.toString(array));
		System.out.println("执行次数：" + test.total);
		array = test.bubbleSort2(array2_2);
		System.out.println("Sort2-2：" + Arrays.toString(array));
		System.out.println("执行次数：" + test.total);
	}
	}
}

鼠标右键，敲击Run，我们来跑程序。

---

总结

时钟滴答滴地响着，我终于敲上了代码的最后一个字符。
我将功能敲好，分别优化出三个函数，并且将它们组织在一个类里。
为了控制机制，我在类中增加两个变量。
测试中，我将主函数编写好，直接放在类里。
我拿起鼠标，看着光标缓缓移动，直到它停在Run处。
轻轻敲击一下，看着熟悉的控制台，我放下手中的鼠标，脱下鞋，爬上床，心满意足地睡了。