1. 冒泡排序
思想：
比较相邻的两个元素，如前一个比后一个大，则交换位置
第一轮的最后一个元素应该是最大的元素
按照步骤1的方法比较相邻两个元素，这个时候因为最后一个元素已经是最大的了，所以最后一个元素不用比较
总共比较 n-1次
双重循环，所以平均复杂度和最坏的复杂度均是是O(n^2)，最好的情况是已经排好序的，所以只遍历一次就可以了，所以是O(n)
代码
function sort(arr) {
for (let i = 0; i < arr.length - 1; i++) {
for (let j = 0; j < arr.length - i -1; j++) {
if(arr[j] > arr[j+1]){
[arr[j],arr[j+1]] = [arr[j+1],arr[j]]
}
}
}
}
var arr = [3,1,5,7,2,4,9,6]
console.log('排序前：'+arr);
sort(arr)
console.log('排序后:'+arr);
2. 快速排序
快排的思想：
通过一趟排序将待排记录分成独立的两个部分，左边元素均比枢纽元素小，右边元素均比枢纽元素大，之后再对这两部分继续排序，直到整个序列有序。（面试有问到）
其实该排序有三种思路，以下的代码是第三种思路，也就是根据阮一峰老师的思路写的
function sort(arr) {
if(arr.length <= 1){
return arr
}
var mid = parseInt(arr.length / 2)
var left = [],right = []
var pivot = arr.splice(mid,1)[0]
arr.forEach(item => {
if(item < pivot){
left.push(item)
}else {
right.push(item)
}
})
return sort(left).concat([pivot],sort(right))
}
var arr = [3,1,5,7,2,4,9,6]
console.log('排序前：'+arr);
console.log('排序后:'+sort(arr));
该方法并不是原地排序。并没有改变原数组，而是将排好序的元素组返回成一个新数组。
若想改变元素组，可以采取第一种思路，双指针
function sort(arr, from, to) {
var i = from, j = to, pivot = arr[from]
if(from >= to) return
while (i < j) {
while (i < j && arr[j] > pivot) {
--j
}
while (i < j && arr[i] < pivot) {
++i
}
if (i < j) {
[arr[i], arr[j]] = [arr[j], arr[i]]
}
}
[arr[i], pivot] = [pivot, arr[i]]
sort(arr, from, i-1)
sort(arr, i + 1, to)
}
var arr = [3, 1, 5, 7, 2, 4, 9, 6]
console.log('排序前：' + arr);
sort(arr,0,arr.length-1)
console.log('排序后:' + arr);
时间复杂度最好和平均均为O(nlgn)，最坏为O(n^2)
至于为什么是这样，可以参考这篇博客：快速排序时间复杂度为O（n×log（n））的证明
3. 选择排序
时间复杂度均为O(n^2)
var arr = [3,5,8,5,2,9]
var index = 0
for(var i = 0;i<arr.length-1;++i){
index = i
for(var j = i+1;j<arr.length;++j){
if(arr[j] < arr[index]){
index = j//保存最小值的索引
}
}
// 如果没变的话，那就不用交换
if(index !== i){
[arr[i],arr[index]] = [arr[index],arr[i]]
}
}
console.log(arr);
