程序员必备的几种常见排序算法和搜索算法总结

前言

最近为了巩固一下本身的算法基础,又把算法书里的基本算法刷了一遍, 特意总结一下前端工程师须要了解的排序算法和搜索算法知识,虽然还有不少高深算法须要了解, 可是基础仍是要好好巩固一下的.本文将以图文的形式为你们介绍以下算法知识,但愿在读完以后你们能有所收获:

• 冒泡排序及其优化
• 选择排序
• 插入排序
• 归并排序
• 快速排序
• 顺序搜索
• 二分搜索

正文

我想对于每一个前端工程师来讲, 最头疼的就是算法问题, 可是算法每每也是衡量一我的编程能力的一个很重要的指标.目前不少主流框架和库都应用了大量的算法和设计模式,为了让本身的段位更高,咱们只能不断的"打怪"(也就是刷算法)升级,才能成为"最强王者".

其实前端发展这么多年, 愈来愈偏向于精细化开发, 不少超级应用(好比淘宝,微信)都在追求极致的用户体验, 时间就是金钱,这要求工程师们不能像之前那样,开发的程序只要能用就行, 咱们每每还要进行更加细致的测试(包括单元测试, 性能测试等),就拿排序来讲, 对于大规模数据量的排序, 咱们采用冒泡排序确定是要被疯狂吐槽的,由于冒泡排序的性能极差(复杂度为O(n^2).在真实项目中咱们每每不会采用冒泡排序,更多的会用快速排序或者希尔排序.关于排序算法性能问题我在

• 《前端算法系列》如何让前端代码速度提升60倍

有详细介绍. 接下来就让咱们来一块儿学习如何实现文章开头的几个经常使用排序和搜索算法吧.

冒泡排序及其优化

咱们在学排序算法时, 最容易掌握的就是冒泡排序, 由于其实现起来很是简单,可是从运行性能的角度来看, 它倒是性能最差的一个.

冒泡排序的实现思路是比较任何两个相邻的项, 若是前者比后者大, 则将它们互换位置.

为了更方便的展现冒泡排序的过程和性能测试,笔者先写几个工具方法,分别为动态生成指定个数的随机数组, 生成元素位置序列的方法,代码以下:

// 生成指定个数的随机数组
const generateArr = (num = 10) => {
  let arr = []
  for(let i = 0; i< num; i++) {
    let item = Math.floor(Math.random() * (num + 1))
    arr.push(item)
  }
  return arr
}

// 生成指定个数的元素x轴坐标
const generateArrPosX = (n= 10, w = 6, m = 6) => {
  let pos = []
  for(let i = 0; i< n; i++) {
    let item = (w + m) * i
    pos.push(item)
  }
  return pos
}

有了以上两个方法,咱们就能够生成任意个数的数组以及数组项坐标了,这两个方法接下来咱们会用到.

咱们来直接写个乞丐版的冒泡排序算法:

bubbleSort(arr = []) {
    let len = arr.length
    for(let i = 0; i< len; i++) {
      for(let j = 0; j < len - 1; j++) {
        if(arr[j] > arr[j+1]) {
          // 置换
          [arr[j], arr[j+1]] = [arr[j+1], arr[j]]
        }
      }
    }
    return arr
  }

接下来咱们来测试一下, 咱们用generateArr方法生成60个数组项的数组, 并动态生成元素坐标:

// 生成坐标
const pos = generateArrPosX(60)
// 生成60个项的数组
const arr = generateArr(60)

执行代码后会生成下图随机节点结构:

有关css部分这里就不介绍了,你们能够本身实现.接下来咱们就能够测试咱们上面写的冒泡排序了,当咱们点击排序时,结果以下:

能够看到数组已按照顺序排好了,咱们可使用console.time来测量代码执行所用的时间,上面"乞丐版"冒泡排序耗时为0.2890625ms.

咱们深刻分析代码就能够知道两层for循环排序致使了不少多余的排序,若是咱们从内循环减去外循环中已跑过的轮数,就能够避免内循环中没必要要的比较,因此咱们代码优化以下:

// 冒泡排序优化版
bubbleSort(arr = []) {
  let len = arr.length
  // 优化
  for(let i = 0; i< len; i++) {
    for(let j = 0; j < len - 1 - i; j++) {
      if(arr[j] > arr[j+1]) {
        // 置换
        [arr[j], arr[j+1]] = [arr[j+1], arr[j]]
      }
    }
  }
  return arr
}

通过优化的冒泡排序耗时:0.279052734375ms, 比以前稍微好了一丢丢, 但仍然不是推荐的排序算法.

选择排序

选择排序的思路是找到数据结构中的最小值并将其放置在第一位,接着找到第二个最小值并将其放到第二位,依次类推.

咱们仍是按照以前的模式,生成一个60项的数组, 以下:

选择排序代码以下:

selectionSort(arr) {
    let len = arr.length,
        indexMin
    for(let i = 0; i< len -1; i++) {
      indexMin = i
      for(let j = i; j < len; j++){
        if(arr[indexMin] > arr[j]) {
          indexMin = j
        }
      }
      if(i !== indexMin) {
        [arr[i], arr[indexMin]] = [arr[indexMin], arr[i]]
      }
    }
    return arr
}

点击排序时, 结果以下:

说明代码运行正常, 能够实现排序, 控制台耗时为: 0.13720703125ms, 明显比冒泡排序性能要好.

插入排序

插入排序 的思路是每次排一个数组项,假定第一项已经排序,接着它和第二项比较, 决定第二项的位置, 而后接着用一样的方式决定第三项的位置, 依次类推, 最终将整个数组从小到大依次排序.

代码以下:

insertionSort(arr) {
    let len = arr.length,
        j,
        temp;
    for(let i = 1; i< len; i++) {
      j = i
      temp = arr[i]
      while(j > 0 && arr[j-1] > temp) {
        arr[j] = arr[j-1]
        j--
      }
      arr[j] = temp;
    }
 }

执行结果以下:


控制台打印耗时为:0.09912109375ms.

归并排序

归并排序算法性能比以上三者都好, 能够在实际项目中投入使用,但实现方式相对复杂.

归并排序是一种分治算法,其思想是将原始数组切分红较小的数组，直到每一个小数组只有一个元素，接着将小数组归并成较大的数组，最后变成一个排序完成的大数组。

其实现过程以下图所示：

为了实现该方法咱们须要准备一个合并函数和一个递归函数，具体实现以下代码：

// 归并排序
mergeSortRec(arr) {
 let len = arr.length
 if(len === 1) {
   return arr
 }
 let mid = Math.floor(len / 2),
     left = arr.slice(0, mid),
     right = arr.slice(mid, len)
 return merge(mergeSortRec(left), mergeSortRec(right))
}
// 合并方法
merge(left, right) {
    let result = [],
        l = 0,
        r = 0;
    while(l < left.length && r < right.length) {
      if(left[l] < right[r]) {
        result.push(left[l++])
      }else {
        result.push(right[r++])
      }
    }
    while(l < left.length) {
      result.push(left[l++])
    }
    while(r < right.length) {
      result.push(right[r++])
    }
    return result
}

以上代码中的递归做用是将一个大数组划分为多个小数组直到只有一项，而后再逐层进行合并排序。若是有不理解的能够和笔者交流或者结合笔者画的草图进行理解。

快速排序

快速排序是目前比较经常使用的排序算法，它的复杂度为O(nlog^n),而且它的性能比其余复杂度为O(nlog^n)的好，也是采用分治的思想，将原始数组进行划分，因为快速排序实现起来比较复杂，这里讲一下思路：

1. 从数组中选择中间项做为主元
2. 建立两个指针，左边一个指向数组第一项，右边一个指向数组最后一项，移动左指针直到咱们找到一个比主元大的元素，移动右指针直到找到一个比主元小的元素，而后交换它们的位置，重复此过程直到左指针超过了右指针
3. 算法对划分后的小数组重复1，2步骤，直到数组彻底排序完成。

代码以下：

// 快速排序
quickSort(arr, left, right) {
    let index
    if(arr.length > 1) {
      index = partition(arr, left, right)
      if(left < index - 1) {
        quickSort(arr, left, index -1)
      }
      if(index < right) {
        quickSort(arr, index, right)
      }
    } 
  }
// 划分流程
partition(arr, left, right) {
    let part = arr[Math,floor((right + left) / 2)],
        i = left,
        j = right
    while(i <= j) {
      while(arr[i] < part) {
        i++
      }
      while(arr[j] > part) {
        j--
      }
      if(i <= j) {
        // 置换
        [arr[i], arr[j]] = [arr[j], arr[i]]
        i++
        j--
      }
    }
    return i
}

顺序搜索

搜索算法也是咱们常常用到的算法之一，好比咱们须要查找某个用户或者某条数据，不论是在前端仍是在后端，都会使用搜索算法。咱们先来介绍最简单也是效率最低的顺序搜索，其主要思想是将每个数据结构中的元素和咱们要查询的元素作比较，而后返回指定元素的索引。

之因此说顺序搜索效率低是由于每次都要从数组的头部开始查询，直到查找到要搜索的值，总体查询不够灵活和动态性。顺序搜索代码实现以下：

sequentialSearch(arr, item) {
    for(let i = 0; i< arr.length; i++) {
      if(item === arr[i]) {
        return i
      }
    }
    return -1
}

接下来咱们看下面一种比较经常使用和灵活的搜索算法——二分搜索。

二分搜索

二分搜索的思想有点“投机学”的意思，可是它是一种有理论依据的“投机学”。首先它要求被搜索的数据结构已排序，其次进行以下步骤：

1. 找出数组的中间值
2. 若是中间值是待搜索的值，那么直接返回中间值的索引
3. 若是待搜索的值比中间值小，则返回步骤1，将区间范围缩小，在中间值左边的子数组中继续搜索
4. 若是待搜索的值比选中的值大，则返回步骤1，将区间范围缩小，在中间值右边的子数组中继续搜索
5. 若是没有搜到，则返回-1

为了方便理解笔者画了以下草图：

由上图你们能够很容易的理解二分搜索的实现过程，接下来咱们看下代码实现：

binarySearch(arr, item) {
    // 调用排序算法先对数据进行排序
    this.quickSort(arr)

    let min = 0,
        max = arr.length - 1,
        mid,
        el
    while(min <= max) {
      mid = Math.floor((min + max) / 2)
      el = arr[mid]
      if(el < item) {
        min = mid + 1
      }else if(el > item) {
        max = mid -1
      }else {
        return mid
      }
    }
    return -1
  }

其实还有不少搜索算法，笔者在js基本搜索算法实现与170万条数据下的性能测试有具体介绍。

最后

若是想学习更多H5游戏, webpack，node，gulp，css3，javascript，nodeJS，canvas数据可视化等前端知识和实战，欢迎在《趣谈前端》学习讨论，共同探索前端的边界。