算法--冒泡排序、选择排序、插入排序

最近没啥好写的，来复习下初级算法吧。

首先重温一下一些算法中的概念：

• 时间复杂度O(n^2)，代表算法所需运行时间，也是算法需要运行的指令数量，是一个最低上界值，n代表数据规模
• 空间复杂度O(1)，代表算法所需内存空间，一般算法为1，递归为n
• 稳定性，排序中的稳定性是指原序列中如有两个相同的值，经过排序后，其相对位置不变即为稳定，反之为不稳定

这里说的选择是直接选择排序算法，插入也是直接插入算法，不是其扩展或变种。

看算法，一定要理解其原理。原理理解了，算法才算掌握了，就算有人让你手写算法，你也能根据原理写个大概。

冒泡排序

冒泡排序是一种利用交换进行排序的算法，在算法中归类为交换排序，其原理是依次遍历相邻的两个值，比较其大小，将小者放在前，大者放在后（升序排序）。
为什么叫冒泡呢？
是因为如果在作升序排列的时候，冒泡算法会把较大的数一位一位往末尾移，看起来就像冒泡一样。

所以用这么几个关键词归纳冒泡排序—相邻、比较、交换。

上代码：

	public void sort(int[] origin) {
		int size = origin.length;
		for (int i = 0; i < size; i++) {
			boolean exchanged = false;
			for (int j = 0; j < size - 1; j++) {
			    //将大者往后移
				if (origin[j] > origin[j + 1]) {
                    exchanged = true;
					int temp = origin[j];
                    origin[j] = origin[j + 1];
                    origin[j + 1] = temp;
				}
			}
			if (!exchanged)
				break;
            System.out.println("第" + (i + 1) + "趟");
            System.out.println(Arrays.toString(origin));
		}
	}

若我们传入7个数：

		int[] origin = {3, 2, 5, 7, 12, 1, 0};

会得到输出：

第1趟
[7, 5, 3, 2, 1, 0, 12]
第2趟
[5, 3, 2, 1, 0, 7, 12]
第3趟
[3, 2, 1, 0, 5, 7, 12]
第4趟
[2, 1, 0, 3, 5, 7, 12]
第5趟
[1, 0, 2, 3, 5, 7, 12]
第6趟
[0, 1, 2, 3, 5, 7, 12]

可以看到，第1趟把最大的数12移到了末尾，第2趟把第二大的数字7移到了倒数第二的位置…依次移动。这就是冒泡。

因为有标记的原因，所以没有走第7趟，不过在最坏的情况下是会走第7趟的，当然，最好的情况就是本身传入的就是有序数列，走一趟就搞定。在没有标记的情况下，永远都会全部比较。

比较和交换都是作为时间考量的指令，所以冒泡算法在最好的情况下，只走一趟，比较6次，因此在最好的情况下时间复杂度为O(n)；最坏的情况下，会走7趟，并且每趟都会比较每个相邻的数字，会比较n*(n-1)=7*6=42次，因此在最坏的情况下时间复杂度为O(n^2)。

只有比较出结果才会交换，所以两个相同的值位置是相对不变的，也就是稳定的。

我们可以在方面外定一个计数器，去验证它。这里不再赘述。

int counter = 0;
if (++counter > 0 && origin[j] > origin[j + 1]) 

直接选择排序

直接选择排序在算法中归类为选择排序，其原理是通过每次遍历，找到当前未排序序列中的最小值，通过放到当前未排序序列的最前端（升序排列）。
整个流程就是依次选择最小值，排列在之前选择的值后面。

其关键词—选择最小值、交换。

看代码：

	public void sort(int[] origin) {
		int size = origin.length;
		for (int i = 0; i < size; i++) {
			int min = origin[i];
			int k = i;
			//通过遍历比较得到当前最小值
			for (int j = i + 1; j < size; j++) {
				if (min > origin[j]) {
                    min = origin[j];
                    k = j;
				}
			}
			//将当前最小值放到应有的位置
			int temp = origin[i];
            origin[i] = origin[k];
            origin[k] = temp;
            System.out.println("第" + (i + 1) + "趟");
            System.out.println(Arrays.toString(origin));
		}
	}

若我们传入7个数：

		int[] origin = {3, 2, 5, 7, 12, 1, 0};

会得到输出：

第1趟
[0, 2, 5, 7, 12, 1, 3]
第2趟
[0, 1, 5, 7, 12, 2, 3]
第3趟
[0, 1, 2, 7, 12, 5, 3]
第4趟
[0, 1, 2, 3, 12, 5, 7]
第5趟
[0, 1, 2, 3, 5, 12, 7]
第6趟
[0, 1, 2, 3, 5, 7, 12]
第7趟
[0, 1, 2, 3, 5, 7, 12]

可以从输出看到，选择排序不会移动其他无关数值的位置，而是针对性地交换每个最小值的所在位置。
但也正因为如此，如果有相同的数值，就有可能被这种“定点交换”破坏了相对位置，因为“当前最小值”的位置是不固定的，与其交换就是有风险的。所以从稳定性来说是不稳定的。

另外，选择排序每次都确定当前的最小值，所以每次都要通过遍历比较得到最小值，共比较n*(n-1)/2次，因此其时间复杂度为O(n^2)。也是因为如此，所以并没有最好情况与最坏情况一说。

直接插入排序

直接插入排序归纳为插入排序阵营，其原理是将前面的数值看作有序数列，并依次将后面的数值通过比较插入前面有序数列中恰当的位置。

整个流程就是一个人打扑克，这个人有从左向右从小到大列牌的习惯，然后依次从左第2张看起，把牌插到前面已经列好的牌里面…（升序排列）

关键—待选数值插入有序数列、依次后移。

不用多说：

	@Override
	public void sort(int[] origin) {
		int size = origin.length;
		for (int i = 1; i < size; i++) {
			//待插入的数值
			int candidate = origin[i];
			int finalIndex = i;
			//遍历寻找应插入的位置索引，把其他值依次白平衡
			while (finalIndex > 0 && candidate < origin[finalIndex - 1]) {
				origin[finalIndex] = origin[finalIndex - 1];
				finalIndex--;
			}
			//把待选值放到应有的位置
			if (finalIndex != i) {
                origin[finalIndex] = candidate;
			}

            System.out.println("第" + i + "趟");
            System.out.println(Arrays.toString(origin));
		}
	}

注意有个依次后移的过程。
现有输入：

		int[] origin = {3, 2, 5, 7, 12, 1, 0};

输出为：

第1趟
[2, 3, 5, 7, 12, 1, 0]
第2趟
[2, 3, 5, 7, 12, 1, 0]
第3趟
[2, 3, 5, 7, 12, 1, 0]
第4趟
[2, 3, 5, 7, 12, 1, 0]
第5趟
[1, 2, 3, 5, 7, 12, 0]
第6趟
[0, 1, 2, 3, 5, 7, 12]

乍看之下，比冒泡排序还要“劳师动众”，每有一个小的数值需要插入，需要大量数值给它“让路”，让它到应有的位置就位。

同样的，因为要依次“让路”的原因，最坏情况下，复杂度是n*(n-1)/2，也就是O(n^2)；最好的情况下，根本不用比较也不用让路，就是O(n)。

也因为是依次“让路”的原因，相同的值相对位置不会有变化，所以是稳定的。

稍稍打个表：

算法	时间复杂度	稳定性
冒泡排序	O(n^2)，有最好情况O(n)	稳定
直接选择排序	O(n^2)	不稳定
直接插入排序	O(n^2)，有最好情况O(n)	稳定