js经典排序算法--面试高频

排序算法复杂度：

1. 冒泡排序

function bubbleSort(arr) {
    var len = arr.length;
    for (var i = 0; i < len - 1; i++) { //比较的趟数,每次将最大值放到数组最后
        for (var j = 0; j < len - i - 1; j++) { //将相邻的两个元素,两两比较
            if (arr[j]>arr[j+1]) { //元素交换值
                var temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
return arr;
}

2. 选择排序
   初始时在未排序序列中找最小(最大)元素,放到序列的起始位置作为已排序序列;然后再从剩余未排序元素中继续寻找最小(大)元素,放到已排序序列的末尾。以此类推。知道所有元素均排序完毕。

function sort(arr){
    var len=arr.length;
    //已排序序列的末尾
    for(var i=0;i<len-1;i++){
        var min=i;
        //待排序序列
        for(var j=i+1;j<len;j++){
             //从待排序序列中找到最小值
            if(arr[j]<arr[min]){
                min=j;
            }
        }
        if(min!=i){
            var temp=arr[i];
            arr[i]=arr[min];
            arr[min]=temp;
        }
    }
    return arr;
}

3. 插入排序
   通过构建有序序列,对未排序数组,在已排序序列中从后向前扫描,找到相应位置并插入。（以第一个元素作为有序数组，其后的元素通过在这个已有序的数组中找到合适的位置并插入。）

function insertSort(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i = 1; i < len; i++) {
        preIndex = i - 1; //排好序的数组最后一个下标
        current = arr[i]; //待排序的数值
           //让待排序的值与排序好的数组值进行比较
        while (preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        //待排序的数值大于等于排序好的值
        arr[preIndex + 1] = current;
    }
    return arr;
}

//插入排序（类比玩扑克抓牌）
function insert(arr) {
    //左手里抓的牌
    let handle = [];
    handle.push(arr[0]);
    for (let i = 1; i < arr.length; i++) {
        //A是新抓的牌
        let A = arr[i];
        //和handle手里的牌依次比较（从后向前比）
        for (let j = handle.length - 1; j >= 0; j--) {
            //每一次要比较的手里的牌
            let B = handle[j];
            //如果当前新牌A比要比较的牌B大，那么就把新牌A插入到B牌后面
            if (A > B) {
                handle.splice(j + 1, 0, A);
                break;
            }
            //已经比较到第一项，则把新牌放到手中最前面即可
            if (j === 0) {
                handle.unshift(A);
            }
        }
    }
    return handle;
}
let arr = [12,23,3,17,65,43,75,5];
console.log(insert(arr));

4.归并排序

该算法采用经典的分治策略。递归的将数组两两分开直到只包含一个元素，然后 将数组排序合并，最终合并为排序好的数组。

function mergeSort(nums){
  if(nums.length<2) return nums;
  
  const middle=Math.floor(nums.length/2);
  const left=nums.slice(0,middle);
  const right=nums.slice(middle);
  return merge(mergeSort(left),mergeSort(right))
}
 
const merge=(left,right)=>{
  const result=[]
  while(left.length&&right.length){
    if(left[0]>right[0]){
      result.push(right.shift())
    }else{
      result.push(left.shift())
    }
  }
  return result.concat(left,right);
}

5.快速排序

function quickSort(arr) {
    if (!arr instanceof Array) {
        return;
    }
    if (arr.length <= 1) {
        return arr;
    }
    var left =[];
    var right = [];
    var mid = Math.floor(arr.length / 2); //获取中间数的索引
    var value = arr.splice(mid, 1); //获取中间数值
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] < value) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat(value, quickSort(right));
}