前端面试之排序算法

选择排序：

原理解析：

　　将未排序的数组中的第一个数据作为基准数据，然后对比除基准数据和已排序数据之外的数据，找到其中的最小数据，然后将最小数据和基准数据进行位置交换。

时间复杂度：

　　时间复杂度O(n^2)

代码实现：

const choseArr = [5, 2, 1, 4, 43, 23, 34]
for (let i = 0; i < choseArr.length - 1; i++) {
　// minIndex用来存储最小的数据下标，i为当前的基准数据下标
  let minIndex = i
  // 这个是用来存储开始的时候数值的index和比较之后最小值的数据
  for (let j = i + 1; j < choseArr.length; j++) {
    if(choseArr[j]<choseArr[minIndex]){
      minIndex=j;
    }
  }
  // 给最小值和最先的换位置
  [choseArr[i],choseArr[minIndex]]=[choseArr[minIndex],choseArr[i]]
}
console.log(choseArr);

 我们这里有一个未排序的数组，我们要对里面的数据进行选择排序，首先是选中第一个为排序的数据作为基准，【下标为0的数据5】，在与后面没有进行排序的数据来进行对比，选择最小的数据然后进行替换。然后在选择下标为1的数据作为基准与后面未排序的数据进行对比替换。

 

数组【3,5,2,0,1】

第一次对比之后：【0，5，2，3，1】；

第二次对比之后：【0，1，2，3，5】；

快速排序【二分排序】：

原理解析：

　　快排又叫二分排序，快排就是在未排序的数据中选择中间的数据作为基准，然后对比其他数据，将比基准数据大的数据放置在右边，然后将比基准数据小的数据放置在左边，之后再左右两边分别选出他们的中间数据作为基准数据，然后再将数据进行对比。大的放置在右边，小的放置在左边；

事件复杂度：

　　O(nlogn)

代码实现：

{
  const quickArr = [1, 5, 2, 9, 64, 3, 28, 1, 189, 75, 6, 8]
  function quickFun(params) {
    // 当进行递归的数组的长度小于等于1的时候直接返回该数组
    if (params.length <= 1) {
      return params
    }
    let middleIndex = Math.floor(params.length / 2) // math.floor() 函数用来返回数字的下舍整数，即它总是将数值向下舍入为最接近的整数。
    console.log(middleIndex)
    // 获取基准数据的下标【floor向下取整】
    let middleItem = params.splice(middleIndex, 1)[0]
    // 截取基准数据比他大的和比他小的
    let leftArr = []
    let rightArr = []
    // 将比基准数据大的数据放置在一个数组中；小的放置在另一个数组中
    for (let k = 0; k < params.length; k++) {
      if (params[k] > middleItem) {
        rightArr.push(params[k])
      } else {
        leftArr.push(params[k])
      }
    }
    // 完成数据的反复调用进行排序，并重新组合成一个新的数组 concat合并数组
    return quickFun(leftArr).concat(middleItem, quickFun(rightArr))
  }
  const quickAns = quickFun(quickArr)
  console.log(quickAns)
}

　　这里面就是对未排序的数组中的数据进行二分排序，在选择基准数据之后分两边进行对比，之后再在两边依次对比，最后知道要对比的数据里面的长度为1，然后直接返回。

冒泡排序：

 　　原理解析：数组中的数据前后两两进行对比，如果后面一个数据小于前面一个则进行交换;

　　事件复杂度：O(n^2)

?

1 2 3 4 5 6 7 8 9 10 11

// 冒泡排序   const popArr = [5,2,1,3,6,8,4,5,7,0,15];   // 因为是前后两两排序，所以只需要数组长度-1 次遍历即可   for (let g = 0; g < popArr.length-1; g++) {     for (let h = 0; h < popArr.length-1; h++) {       if (popArr[h] > popArr[h+1]) {         [popArr[h],popArr[h+1]] = [popArr[h+1],popArr[h]];       }     }   }   console.log(popArr,'----------------------冒泡排序');

 以 const popArr = [5,2,1,3,6,8,4,5,7,0,15]; 为例。

因为 5 > 2 ，所以进行交换：[2,5, 1,3,6,8,4,5,7,0,15]；

因为 5 > 1 ，所以进行交换：[2,1,5, 3,6,8,4,5,7,0,15]；

因为 5 > 3 ，所以进行交换：[2,1,3,5, 6,8,4,5,7,0,15]；

因为 5 < 6 ，所以不进行交换[2,1,3,5,6,8,4,5,7,0,15]；

因为 6 < 8 ，所以不进行交换[2,1,3,5,6,8,4,5,7,0,15]；

因为 8 > 4 ，所以进行交换：[2,1,3,5,6,4,8, 5,7,0,15]；

因为 8 > 5 ，所以进行交换：[2,1,3,5,6,4,5,8, 7,0,15]；

因为 8 > 7 ，所以进行交换：[2,1,3,5,6,4,5,7,8, 0,15]；

因为 8 > 0 ，所以进行交换：[2,1,3,5,6,4,5,7,0,8, 15]；