前面的几篇文章讲了一些基础的数据结构类型，这次我们就深入算法，先从简单的排序算法说起。在排序算法中，入门必学的三个算法分别是冒泡排序、插入排序和选择排序。下面就具体讲一下这三个算法的原理和代码实现
一、冒泡排序（Bubble Sort）
冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。
打个比方，比如[6, 5, 4, 3, 2, 1]，先从下标为0的元素开始，第一个位元素比第二位大，所以第一位与第二位的位置互相交互，然后第二位与第三位的互相比较，第二位的比第三位的大，这两位互相交互，以此类推。当完成一轮比较后就会从下标位1的元素开始重复上述过程，直到下标为n-1时则停止。所以可以得出时间复杂度是。下面是具体的代码实现：
var arr = [5,3,6,2,8,1,9,4,7,10,11,34,12]
var index = 0
while (index < arr.length - 1) {
for (var i = 0; i < arr.length - index; i++) {
var temp = ''
if (arr[i] > arr[i+1]) {
temp = arr[i+1]
arr[i+1] = arr[i]
arr[i] = temp
}
}
++index
}在这里提一个知识点，如果涉及到两数交换的话除了用一个临时变量来暂存这种方法外，还有用异或运算来实现两数交换。上述的代码可以改写如下：
var arr = [5,3,6,2,8,1,9,4,7,10,11,34,12]
var index = 0
while (index < arr.length - 1) {
for (var i = 0; i < arr.length - index; i++) {
var temp = ''
if (arr[i] > arr[i+1]) {
arr[i] = arr[i] ^ arr[i+1]
arr[i+1] = arr[i] ^ arr[i+1]
arr[i] = arr[i] ^ arr[i+1]
}
}
++index
}异或运算是位运算，也就是将数字转换成二进制来运算。异或运算是两个数相同位上的数互相比较，只要是相同则返回0，不同则为1。拿个简单的例子：
var a = 1, b = 2
a = a ^ b
b = a ^ b
a = a ^ b第一步异或运算里，a为1，对应的二进制是01，b为2对应的二进制是10，所以运算后a为11，也就是3。第二步的异或运算里，a为11，b为10，运算后可得b为01，也就是1。到第三步里，a为11，b为01，可得a为10，也就是2。这就不利用临时变量来实现两数交换。位运算在处理数据量比较大的情况下十分的高效，但是由于冒泡排序算法的时间复杂度太高，所以在大数据的情况下还不如换另一种时间复杂度低的算法。
冒泡排序除了上述利用位运算来优化外还可以通过判断后面的元素是否有交换来提前结束冒泡，优化改进如下：
var arr = [5,3,6,2,8,1,9,4,7,10,11,34,12]
var index = 0
while (index < arr.length - 1) {
var state = false
for (var i = 0; i < arr.length - index; i++) {
var temp = ''
if (arr[i] > arr[i+1]) {
temp = arr[i+1]
arr[i+1] = arr[i]
arr[i] = temp
state = true
}
}
if (!state) break
++index
}在这里，如果判断到后面没有发生交换，则可以判断后面的元素已经有序，则不需要再次遍历数组，提高了算法的性能。
二、插入排序（Insertion Sort）
插入排序的思想比上面的冒泡排序的思想要复杂一点。插入排序是将数组分成两个区间，一个是有序区间，一个是无序区间。一般的会将数组第一个元素默认为有序区间，然后将无序区间中的元素插入到有序区间相应的位置中，直到无序区间为0为止，时间复杂度是。代码如下：
for (var i = 1; i < n; ++i) {
var value = a[i];
// 查找插入的位置
for (var j = i - 1; j >= 0; --j) {
if (a[j] > value) {
a[j+1] = a[j]; // 数据移动
} else {
break;
}
}
a[j+1] = value; // 插入数据
}
三、选择排序（Selection Sort）
选择排序和上面的插入排序类似，也是分有一个有序区间和无序区间，与插入排序不同的是，选择排序里插入到有序区间的元素是无序区间里的最小值，时间复杂度是。代码如下：
var arr = [5,3,6,2,8,1,9,4,7,10,11,34,12]
for (var i = 0; i < arr.length - 1; i++) {
var min = arr[i]
var index = i
for (var j = i; j < arr.length; j++) {
if (min > arr[j]) {
min = arr[j]
index = j
}
}
var temp = arr[i]
arr[i] = min
arr[index] = temp
}四、排序算法的分析
在用算法的时候，不止要懂原理，也要懂如何根据它的性能来使用到不同的场景中，下面就以三个点来说一下算法性能的分析。
1.执行效率
我们在分析算法的时间复杂度的时候，要分别的列出最好情况、最坏情况合评价情况的时间复杂度。为什么要做区分呢，首先为了算法之间更好的对比性能，其次是有些极端情况，比如说在高度有序或者杂乱无章的情况下执行的时间会各有不同，所以我们要知道排序算法在不同数据下的性能表现。
除此以外，之前所要忽略的系数、常数、低阶也要考虑进来。我们知道，时间复杂度反应的是数据规模 n 很大的时候的一个增长趋势，所以它表示的时候会忽略系数、常数、低阶。但是实际的软件开发中，我们排序的可能是 10 个、100 个、1000 个这样规模很小的数据，所以，在对同一阶时间复杂度的排序算法性能对比的时候，我们就要把系数、常数、低阶也考虑进来。
还有一点，在上面说提到的三个基于比较的排序算法，都涉及到比较和替换。所以，如果我们在分析排序算法的执行效率的时候，应该把比较次数和交换（或移动）次数也考虑进去。
2.内存消耗
算法的内存消耗其实就是算法所额外占用空间的多少，可以通过空间复杂度来衡量。针对排序算法的空间复杂度，这里引入了一个新概念原地排序（Sorted in place）。原地排序算法，就是特指空间复杂度是 O(1) 的排序算法。我们上面讲的三种排序算法，都是原地排序算法。
3.算法的稳定型
仅仅用执行效率和内存消耗来衡量排序算法的好坏是不够的。针对排序算法，我们还有一个重要的度量指标，稳定性。这个概念是说，如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变。
比如一组数据5，2，3，2，6，1。经排序后可得1，2，2，3，5，6。这组数据里有两个 2。经过某种排序算法排序之后，如果两个 2 的前后顺序没有改变，那我们就把这种排序算法叫作稳定的排序算法；如果前后顺序发生变化，那对应的排序算法就叫作不稳定的排序算法。
可能看着这个例子看不出什么起来，但是如果要排序的是对象元素，则很容易看出算法的稳定性。比如说，我们现在要给电商交易系统中的“订单”排序。订单有两个属性，一个是下单时间，另一个是订单金额。如果我们现在有 10 万条订单数据，我们希望按照金额从小到大对订单数据排序。对于金额相同的订单，我们希望按照下单时间从早到晚有序。对于这样一个排序需求，我们怎么来做呢？借助稳定排序算法，这个问题可以非常简洁地解决。解决思路是这样的：我们先按照下单时间给订单排序，注意是按照下单时间，不是金额。排序完成之后，我们用稳定排序算法，按照订单金额重新排序。两遍排序之后，我们得到的订单数据就是按照金额从小到大排序，金额相同的订单按照下单时间从早到晚排序的。为什么呢？
稳定排序算法可以保持金额相同的两个对象，在排序之后的前后顺序不变。第一次排序之后，所有的订单按照下单时间从早到晚有序了。在第二次排序中，我们用的是稳定的排序算法，所以经过第二次排序之后，相同金额的订单仍然保持下单时间从早到晚有序。如果是先排金额再排时间的话，排时间的时候可能某个很前的时间端有个很大的金额，这个时候大金额可能排到前面导致不能满足先金钱有序的前提。下面就以上面的三个算法来更加详细的说明。
五、三个排序算法之间的比较
首先以是否是原地排序算法为例。冒泡排序算法涉及到相邻的交换和比较操作，只需要常量级的临时空间，所以空间复杂度是O(1)， 是原地排序算法。插入排序和冒泡排序一样也执行了交换和比较操作，所以也是原地排序，空间复杂度为1。同理，由于选择排序和插入排序类似，所以也是原地排序算法。
再来说一下是否是稳定排序算法。在冒泡排序中，只有交换才可以改变两个元素的前后顺序。为了保证冒泡排序算法的稳定性，当有相邻的两个元素大小相等的时候，我们不做交换，相同大小的数据在排序前后不会改变顺序，所以冒泡排序是稳定的排序算法。
在插入排序中，对于值相同的元素，我们可以选择将后面出现的元素，插入到前面出现元素的后面，这样就可以保持原有的前后顺序不变，所以插入排序是稳定的排序算法。
那选择排序是稳定排序算法吗？答案是否定的，选择排序是一种不稳定的排序算法。选择排序的定义里，每次都要找剩余未排序元素中的最小值，并和前面的元素交换位置，这样破坏了稳定性。
六、有序度和无序度
在进行时间复杂度的比较之前，我们先来过一下有序度和无序度。我们先以冒泡排序为例。如果一组数据已经排好序了，那么在用冒泡排序进行排序的时候，只需遍历一层循环则可以了得出结果，所以最好时间复杂度是O(n)。但是如果数据是完全倒序，则要进行n次冒泡操作，则最坏条件下时间复杂度是。这个时候求平均时间复杂度的时候就用到标题上写的有序度和无序度了。
有序度是数组中具有有序关系的元素对的个数。有序元素对用数学表达式表示就是这样：
有序元素对：a[i] <= a[j], 如果 i < j。
比如3，4，6，5，2，1这个数据里，有序度为5，有序元素的对数分别是(3,4), (3,6), (3,5), (4,6), (4,5)。对于有序度是n*(n-1)/2，我们可以把它称作为满有序度，而逆序度的计算公式则是满有序度减有序度。
我们从上面知道，冒泡排序包含两个操作原子，比较和交换。每交换一次，有序度就加 1。不管算法怎么改进，交换次数总是确定的，即为逆序度，也就是n*(n-1)/2–初始有序度。如上面的3，4，6，5，2，1这个例子，则要进行10次交换操作。
对于包含 n 个数据的数组进行冒泡排序，平均交换次数是多少呢？最坏情况下，初始状态的有序度是 0，所以要进行 n*(n-1)/2 次交换。最好情况下，初始状态的有序度是 n*(n-1)/2，就不需要进行交换。我们可以取个中间值 n*(n-1)/4，来表示初始有序度既不是很高也不是很低的平均情况。换句话说，平均情况下，需要 n*(n-1)/4 次交换操作，比较操作肯定要比交换操作多，而复杂度的上限是 ，所以平均情况下的时间复杂度就是
。
在插入排序中，如果要排序的数据已经是有序的，我们并不需要搬移任何数据。如果我们从尾到头在有序数据组里面查找插入位置，每次只需要比较一个数据就能确定插入的位置。所以这种情况下，最好是时间复杂度为 O(n)。注意，这里是从尾到头遍历已经有序的数据。如果数组是倒序的，每次插入都相当于在数组的第一个位置插入新的数据，所以需要移动大量的数据，所以最坏情况时间复杂度为 。在前面的文章中我们得知，在数组中插入一个数据的平均时间复杂度是多少吗？没错，是 O(n)。所以，对于插入排序来说，每次插入操作都相当于在数组中插入一个数据，循环执行 n 次插入操作，所以平均时间复杂度为
。
同理，我们可以通过上面的两个算法可以得出选择排序的最快时间复杂度是O(n)，最慢时间复杂度是，平均时间复杂度是
。
在这里我们可以得出一个结论，由于选择排序不是一个稳定性排序算法，即使和冒泡和插入排序一样是原地排序算法和时间复杂度一样，但由于这个缺点，所以就选择插入排序或冒泡排序。而在冒泡排序和插入排序中对比，我们可以发现冒泡排序的数据交换要比插入排序的数据移动要复杂，冒泡排序需要 3 个赋值操作，而插入排序只需要 1 个。插入排序比冒泡排序少了两个步骤使得它的性能比冒泡排序要好一点。可能在小数据下看不出来，但是涉及到大数据的情况下这点细微的差别就会被放大出来了。
