JS数据结构与算法_排序和搜索算法

开发 前端 算法
这是《学习JavaScript数据结构与算法》的最后一篇博客,也是在面试中常常会被问到的一部分内容:排序和搜索。

 写在前面

这是《学习JavaScript数据结构与算法》的***一篇博客,也是在面试中常常会被问到的一部分内容:排序和搜索。在这篇博客之前,我每每看到排序头就是大的,心里想着类似“冒泡排序,两层遍历啪啪啪“就完事了,然后再也无心去深入研究排序相关的问题了。如果你也有类似的经历,希望下面的内容对你有一定帮助

一、准备

在进入正题之前,先准备几个基础的函数

(1)交换数组两个元素 

  1. function swap(arr, sourceIndex, targetIndex) {  
  2.   let temp = arr[sourceIndex];  
  3.   arr[sourceIndex] = arr[targetIndex];  
  4.   arr[targetIndex] = temp;  

(2)快速生成0~N的数组 可点击查看更多生成方法 

  1. function createArr(length) {  
  2.   return Array.from({length}, (_, i) => i);  

(3)洗牌函数

洗牌函数可快速打乱数组,常见的用法如切换音乐播放顺序 

  1. function shuffle(arr) {  
  2.   for (let i = 0; i < arr.length; i += 1) {  
  3.     const rand = Math.floor(Math.random() * (i + 1));  
  4.     if (rand !== i) {  
  5.       swap(arr, i, rand);  
  6.     }  
  7.   }  
  8.   return arr;  

二、排序

常见排序算法可以分为两大类:

  •  比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此也称为非线性时间比较类排序
  •  非比较类排序:不通过比较来决定元素间的相对次序,它可以突破基于比较排序的时间下界,以线性时间运行,因此也称为线性时间非比较类排序

在本篇博客中,仅对比较类排序的几种排序方式进行学习介绍

2.1 冒泡排序

冒泡排序是所有排序算法中最简单的,通常也是我们学习排序的入门方法。但是,从运行时间的角度来看,冒泡排序是最差的一种排序方式。

核心:比较任何两个相邻的项,如果***个比第二个大,则交换它们。元素项向上移动至正确的顺序,就好像气泡升至表面一样,冒泡排序因而得名

注意:***层遍历找出剩余元素的***值,至指定位置【依次冒泡出***值】

代码: 

  1. function bubbleSort(arr) {  
  2.   const len = arr.length;  
  3.   for (let i = 0; i < len; i += 1) {  
  4.     for (let j = 0; j < len - 1 - i; j += 1) {  
  5.       if (arr[j] > arr[j + 1]) { // 比较相邻元素  
  6.         swap(arr, j, j + 1);  
  7.       }  
  8.     }  
  9.   }  
  10.   return arr;  

2.2 选择排序

选择排序是一种原址比较排序算法。

核心:首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕

注意:***层遍历找出剩余元素最小值的索引,然后交换当前位置和最小值索引值【依次找到最小值】

代码: 

  1. function selectionSort(arr) {  
  2.   const len = arr.length;  
  3.   let minIndex;  
  4.   for (let i = 0; i < len - 1; i += 1) {  
  5.     minIndex = i;  
  6.     for (let j = i + 1; j < len; j += 1) {  
  7.       if (arr[minIndex] > arr[j]) {  
  8.         minIndex = j; // 寻找最小值对应的索引  
  9.       }  
  10.     }  
  11.     if (minIndex === i) continue;  
  12.     swap(arr, minIndex, i);  
  13.   }  
  14.   return arr;  

2.3 插入排序

插入排序的比较顺序不同于冒泡排序和选择排序,插入排序的比较顺序是当前项向前比较。

核心:通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入

注意:从第二项开始,依次向前比较,保证当前项以前的序列是顺序排列

代码: 

  1. function insertionSort(arr) {  
  2.   const len = arr.length;  
  3.   let current, pointer;  
  4.   for (let i = 1; i < len; i += 1) {  
  5.     current = arr[i];  
  6.     pointer = i;  
  7.     while(pointer >= 0 && current < arr[pointer - 1]) { // 每次向前比较  
  8.       arr[pointer] = arr[pointer - 1]; // 前一项大于指针项,则向前移动一项  
  9.       pointer -1 
  10.     }  
  11.     arr[pointer] = current; // 指针项还原成当前项  
  12.   }  
  13.   return arr;  

2.4 归并排序

归并排序和快速排序相较于上面三种排序算法在实际中更具有可行性(在第四小节我们会通过实践复杂度来比较这几种排序算法)

JavaScript的Array类定义了一个sort函数(Array.prototype.sort)用以排序JavaScript数组。ECMAScript没有定义用哪个排序算法,所以浏览器厂商可以自行去实现算法。例如,Mozilla Firefox使用归并排序作为Array.prototype.sort的实现,而Chrome使用了一个快速排序的变体

归并排序是一种分治算法。其思想是将原始数组切分成较小的数组,直到每个小数组只有一 个位置,接着将小数组归并成较大的数组,直到***只有一个排序完毕的大数组。因此需要用到递归

核心:归并排序,拆分成左右两块数组,分别排序后合并

注意:递归中最小的左右数组比较为单个元素的数组,因此在较上层多个元素对比时,左右两个数组一定是顺序的

代码: 

  1. function mergeSort(arr) {  
  2.   const len = arr.length;  
  3.   if (len < 2) return arr; // 递归的终止条件  
  4.   const middle = Math.floor(len / 2); // 拆分左右数组  
  5.   const left = arr.slice(0, middle);  
  6.   const right = arr.slice(middle);  
  7.   return merge(mergeSort(left), mergeSort(right));  
  8.  
  9. function merge(left, right) { // 将左右两侧比较后进行合并  
  10.   const ret = [];  
  11.   while (left.length && right.length) {  
  12.     if (left[0] > right[0]) {  
  13.       ret.push(right.shift());  
  14.     } else {  
  15.       ret.push(left.shift());  
  16.     }  
  17.   }  
  18.   while (left.length) {  
  19.     ret.push(left.shift());  
  20.   }  
  21.   while (right.length) {  
  22.     ret.push(right.shift());  
  23.   }  
  24.   return ret;  

2.5 快速排序

快速排序也许是最常用的排序算法了。它的复杂度为O(nlogn),且它的性能通常比其他的复 杂度为O(nlogn)的排序算法要好。和归并排序一样,快速排序也使用分治的方法,将原始数组分为较小的数组

核心:分治算法,以参考值为界限,将比它小的和大的值拆开

注意:每一次遍历筛选出比基准点小的值

代码: 

  1. function quickSort(arr, left = 0right = arr.length - 1) {  
  2.   // left和right默认为数组首尾  
  3.   if (left < right) {  
  4.     let partitionpartitionIndex = partition(arr, left, right);  
  5.     quickSort(arr, left, partitionIndex - 1);  
  6.     quickSort(arr, partitionIndex + 1, right);  
  7.   }  
  8.   return arr;  
  9.  
  10. function partition(arr, left, right) {  
  11.   let pivot = left 
  12.   let index = left + 1; // 满足比较条件的依次放在分割点后  
  13.   for (let i = index; i <= right; i += 1) {  
  14.     if (arr[i] < arr[pivot]) {  
  15.       swap(arr, i, index);  
  16.       index += 1;  
  17.     }  
  18.   }  
  19.   swap(arr, index - 1, pivot); // 交换顺序时,以***一位替换分隔项  
  20.   return index - 1;  

三、搜索算法

3.1 顺序搜索

顺序或线性搜索是最基本的搜索算法。它的机制是,将每一个数据结构中的元素和我们要找的元素做比较。顺序搜索是***效的一种搜索算法。 

  1. function findItem(item, arr) {  
  2.   for (let i = 0; i < arr.length; i += 1) {  
  3.     if (item === arr[i]) {  
  4.       return i;  
  5.     }  
  6.   }  
  7.   return -1;  

3.2 二分搜索

二分搜索要求被搜索的数据结构已排序。以下是该算法遵循的步骤:

  1.     选择数组的中间值
  2.     如果选中值是待搜索值,那么算法执行完毕
  3.     如果待搜索值比选中值要小,则返回步骤1在选中值左边的子数组中寻找
  4.     如果待搜索值比选中值要大,则返回步骤1在选中值右边的子数组中寻找 
  1. function binarySearch(item, arr) {  
  2.   arr = quickSort(arr); // 排序  
  3.   let low = 0 
  4.   let high = arr.length - 1;  
  5.   let mid;  
  6.   while (low <= high) {  
  7.     min = Math.floor((low + high) / 2);  
  8.     if (arr[mid] < item) {  
  9.       low = mid + 1;  
  10.     } else if (arr[mid] > item) {  
  11.       high = mid - 1;  
  12.     } else {  
  13.       return mid;  
  14.     }  
  15.   }  
  16.   return -1;  

四、算法复杂度

4.1 理解大O表示法

大O表示法用于描述算法的性能和复杂程度。分析算法时,时常遇到一下几类函数

(1)O(1) 

  1. function increment(num){  
  2.     return ++num;  

执行时间和参数无关。因此说,上述函数的复杂度是O(1)(常数)

(2)O(n)

以顺序搜索函数为例,查找元素需要遍历整个数组,直到找到该元素停止。函数执行的总开销取决于数组元素的个数(数组大小),而且也和搜索的值有关。但是函数复杂度取决于最坏的情况:如果数组大小是10,开销就是10;如果数组大小是1000,开销就是1000。这种函数的时间复杂度是O(n),n是(输入)数组的大小

(3)O(n2)

以冒泡排序为例,在未优化的情况下,每次排序均需进行n*n次执行。时间复杂度为O(n2)

时间复杂度O(n)的代码只有一层循环,而O(n2)的代码有双层嵌套循环。如 果算法有三层遍历数组的嵌套循环,它的时间复杂度很可能就是O(n3) 

4.2 时间复杂度比较

(1)常用数据结构时间复杂度

(2)排序算法时间复杂度

责任编辑:庞桂玉 来源: segmentfault
相关推荐

2023-03-10 08:07:39

数据结构算法计数排序

2023-03-02 08:15:13

2023-04-27 09:13:20

排序算法数据结构

2023-03-07 08:02:07

数据结构算法数列

2023-03-13 10:08:31

数据结构算法

2023-03-08 08:03:09

数据结构算法归并排序

2021-04-15 09:36:44

Java数据结构算法

2021-07-16 04:57:45

Go算法结构

2021-03-23 08:33:22

Java数据结构算法

2022-09-24 09:03:55

前端单元测试冒泡排序

2021-09-04 23:40:53

算法程序员前端

2020-10-21 14:57:04

数据结构算法图形

2023-02-09 07:39:01

2021-11-10 09:17:18

程序员排序算法搜索算法

2023-10-27 07:04:20

2009-08-03 17:38:12

排序算法C#数据结构

2023-03-06 08:10:52

数据结构算法数据

2021-04-16 09:40:52

Java数据结构算法

2023-04-14 08:07:20

数据结构算法搜索

2021-04-22 10:07:45

Java数据结构算法
点赞
收藏

51CTO技术栈公众号