排序是我们生活中经常面对的问题，做操时需要从小到大排序，我们逛电商网站，常常按价格排序。像这样我们把多个序列按照关键词递增（递减）的方式进行排列，使得序列成为一个按关键字有序的序列，这样的操作就称为排序。
冒泡排序是一种交换排序，它的基本思想是：两两比较相邻的关键字，如果反序则交换位置，知道没有反序的记录为止
时间复杂度：最快的情况下是所有的元素已经是正序 冒泡排序的时间复杂度为o(n²），代码如下
function bubleSort (arr) {
var len = arr.length;
for(var i = 0;i < len;i++){
for(var j = 0;j < len-l-i;j++){
if(arr[i]>arr[i+1]){
var temp = arr[j+1];
arr[j+1] = arr[j];
temp = arr[j]
}
}
}
return arr
}
冒泡排序的思想就是不断交换位置，而选择排序的初步思想就是在排序时找到合适的关键字再做交换。分析它的时间复杂度发现，无论最好最差的情况，其比较次数都是一样多，第i趟排序需要进行i-1次关键字的比较，此时需要比较n(n-1)/2,总的时间复杂度依然是o(n²）,代码如下
function selectSort(arr){
var len = arr.length;
var minIndex
for(var i = 0 ;i<len;i++){
minIndex = i;
for(var j = i+1;j < len;j++){
if(arr[j]<arr[minIndex]){
minIndex = j;
}
}
var temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
return arr
}
插入排序的理解就像手里的扑克牌，抓牌的时候把牌按顺序在手牌中插入，插入排序的时间复杂度为o(n²）
function insertsort(){
var len = arr.length;
var pre ,current;
for(var i = 0; i<arr.len;i++){
pre= i -1 ;
current = arr[i];
while(pre>0&&arr[pre]>current){
arr[pre+1]= arr[pre];
pre--
}
arr[pre] = current;
}
return arr
}
归并排序的宗旨是递归，总的时间复杂度为o(nlogn)
function mergeSort(arr){
var len = arr.length;
if(len<2){
return arr
}
var middle = Math.floor(len/2);
var left = arr.slice(0,middle);
var right = arr.slice(middle);
return merge(mergeSort(left),mergeSort(right))
};
function merge(left,right)(){
var result = {};
while(left.length>0&&right.length>0){
if(left[0]<=right[0]){
result.push(left.shift())
}
else{
result.push(right.shift)
}
while(left.length){
result.push(left.shift())
}
while(right.length){
result.push(right.shift())
}
return result
}
}
通过一趟排序将待排记录分割成独立的两部分，其中一部分关键字均比另一部分关键字小，则可分别对这两部分记录继续进行排序，快速排序的时间复杂度虽然达到了o(n²）,但是比大多数平均时间复杂度为o(nlogn)的排序算法表现更好
var quickSort = function(arr) {
if (arr.length <= 1) {//如果数组长度小于等于1无需判断直接返回即可
return arr;
}
var pivotIndex = Math.floor(arr.length / 2);//取基准点
var pivot = arr.splice(pivotIndex, 1)[0];//取基准点的值,splice(index,1)函数可以返回数组中被删除的那个数
var left = [];//存放比基准点小的数组
var right = [];//存放比基准点大的数组
for (var i = 0; i < arr.length; i++){ //遍历数组，进行判断分配
if (arr[i] < pivot) {
left.push(arr[i]);//比基准点小的放在左边数组
} else {
right.push(arr[i]);//比基准点大的放在右边数组
}
}
//递归执行以上操作,对左右两个数组进行操作，直到数组长度为<=1；
return quickSort(left).concat([pivot], quickSort(right));
}
}
