使用java实现冒泡排序和选择排序

冒泡排序原理

假设有10个数，第一轮循环，第一个数和第二个数比较，如果第一个数大，第一个数和第二个数交换位置，否则不动；接着第二个数和第三个数比较，如果第二个数大，第二个数和第三个数交换位置，否则不动…第九个数和第十个数比较，如果第九个数大，第九个数和第十个数交换位置，否则不动。第一轮循环结束，最大的数挪到了第十个数的位置，比较进行了9次。
第二轮循环，第一个数和第二个数比较，如果第一个数大，第一个数和第二个数交换位置，否则不动…第八个数和第九个数比较，如果第八个数大，第八个数和第九个数交换位置，否则不动。第二轮循环结束，第二大的数挪到了第九个数的位置，比较进行了8次。
…
第九轮循环，第一个数和第二个数比较，如果第一个数大，第一个数和第二个数交换位置，否则不动。第九轮循环结束，倒数第二大的数挪到了第二个数的位置，比较进行了1次。
总体原理：每轮比较找到最大的数。

冒泡排序实现思路

先写出内循环

			for (int i = 0; i < a.length - 1 ; i++) {
				if (a[i] > a[i + 1]) {
					// change
					temp = a[i + 1];
					a[i + 1] = a[i];
					a[i] = temp;
				}
			}

这个比较好理解，就是第一轮循环
那么第二轮怎么比较呢？其实比较和上一轮几乎一样，只不过比较次数比第一次少1次
第三轮怎么比较呢？其实比较和上一轮几乎一样，只不过比较次数比第二次少1次
…
所以我们要复用内循环，而内循环的次数由i < a.length - 1 决定，那么，我们要使它每轮循环后递减，不难想到，可以再嵌套循环，将条件改为i < a.length - 1-j;j从零递增，那么第一次，内循环执行了 a.length - 1-0次；第二次，内循环执行了 a.length - 1-1…第九次执行了a.length-1-8次（a.length=10）

冒泡排序的java实现

public class BubbleSort {
	public static void main(String[] args) {
		int a[] = { 2, 3, 6, 4, 0, 1, 7, 8, 5, 9 };
		bubbleSort(a);
	}

	public static void toString(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}

	private static void bubbleSort(int[] a) {
		int length = a.length;
		int temp = 0;
		for (int j = 0; j < a.length - 1; j++) {
			for (int i = 0; i < a.length - 1 - j; i++) {
				if (a[i] > a[i + 1]) {
					// change
					temp = a[i + 1];
					a[i + 1] = a[i];
					a[i] = temp;
				}
			}
		}
		toString(a);
	}
}

冒泡排序的比较示意图

选择排序原理

假设有10个数，第一轮循环，第一个数和第二个数比较，如果第一个数大，第一个数和第二个数交换位置，否则不动；接着第一个数和第三个数比较，如果第一个数大，第一个数和第三个数交换位置，否则不动…第一个数和第十个数比较，如果第一个数大，第一个数和第十个数交换位置，否则不动。第一轮循环结束，最小的数挪到了第一个数的位置，比较进行了9次。
第二轮循环，第二个数和第三个数比较，如果第二个数大，第而个数和第三个数交换位置，否则不动…第二个数和第十个数比较，如果第二个数大，第二个数和第十个数交换位置，否则不动。第二轮循环结束，第二小的数挪到了第二个数的位置，比较进行了8次。
…
第九轮循环，第九个数和第十个数比较，如果第九个数大，第九个数和第十个数交换位置，否则不动。第九轮循环结束，倒数第二小的数挪到了倒数第二个的位置，比较进行了1次。

选择排序（伪）的实现思路

先写内循环，第一轮比较应该是这样

			for (int i = 0; i < length- 1; i++) {
				if (a[0] > a[i + 1]) {
					// change
					temp = a[0];
					a[0] = a[i + 1];
					a[i + 1] = temp;
				}
			}

执行完毕后最小的数到0的位置
第二次应该这样

			for (int i = 1; i < length- 1; i++) {
				if (a[1] > a[i + 1]) {
					// change
					temp = a[1];
					a[1] = a[i + 1];
					a[i + 1] = temp;
				}
			}

可以推导出以下代码

		for (int j = 0; j <length- 1;j++) {
			for (int i = j; i < length- 1; i++) {
				if (a[j] > a[i + 1]) {
					// change
					temp = a[j];
					a[j] = a[i + 1];
					a[i + 1] = temp;
				}
			}
		}

选择排序（伪）的java实现

public class SeletSort {
	public static void main(String[] args) {
		int a[] = { 2, 3, 6, 4, 0, 1, 7, 8, 5, 9 };
		seletSort(a);
	}

	public static void toString(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}

	private static void seletSort(int[] a) {
		int length = a.length;
		int temp = 0;
		for (int j = 0; j <length- 1;j++) {
			for (int i = j; i < length- 1; i++) {
				if (a[j] > a[i + 1]) {
					// change
					temp = a[j];
					a[j] = a[i + 1];
					a[i + 1] = temp;
				}
			}
		}
		toString(a);
	}
}

选择排序的动态示意图

选择排序（真）的写法

在网上看算法动态图时发现，很多选择排序在每一轮比较会记住最小数字的下标，在这一轮比较结束后将最小的数和这一轮比较的第一个数交换。而不是像上面那样每比较一次都有可能交换，因为上面一种算法没有记录最小元素的下标。按这种实现，代码应该写成这样：

	private static void seletSort(int[] a) {
		int length = a.length;
		int temp = 0;
		int minIndex;
		for (int j = 0; j <length- 1;j++) {
			minIndex = j;
			for (int i = j; i < length- 1; i++) {
				if (a[minIndex] > a[i + 1]) {
					minIndex = i+1;
				}
			}
			temp = a[minIndex];
			a[minIndex]= a[j];
			a[j]=temp;
		}
		toString(a);
	}

选择排序的意思应该是，在一轮比较中，选择当前比较数中最小的那个，放到最前面的位置，从这个角度看，第二种写法更符合选择排序这个名字呢。（这样写避免了无意义的交换）

推荐：算法动图演示

以下是算法动态图演示，可以帮助理解。
动图演示blog