進階算法之“搜索排序”

• 排序和搜索簡介
• • 排序和搜索是什么？
  • JS中的排序和搜索
  • 排序算法
  • 搜索算法
• Javascript實現：冒泡排序
• Javascript實現：選擇排序
• Javascript實現：插入排序
• Javascript實現：歸并排序
• Javascript實現：快速排序
• Javascript實現：順序搜索
• Javascript實現：二分搜索
• LeetCode：21.合并兩個有序鏈表
• LeetCode：374.猜數字大小
• 思考題

排序和搜索簡介

排序和搜索是什么？

排序：把某個亂序的數組變成升序或者降序的數組
搜索：找出數組中某個元素的下標

JS中的排序和搜索

JS中的排序：數組的sort方法
JS中的搜索：數組的indexOf方法

排序算法

冒泡排序，O(n^2)
選擇排序，O(n^2)
插入排序，O(n^2)
歸并排序，O(n * logN)
快速排序，O(n * logN)
…

搜索算法

順序搜索，O(n)
二分搜索，O(logN)
…

Javascript實現：冒泡排序

冒泡排序的思路
比較所有相鄰元素，如果第一個比第二個大，則交換它們
一輪下來，可以保證最后一個數是最大的
執行n-1輪，就可以完成排序

可以在https://visualgo.net/zh/sorting網站上查看算法動畫效果

Array.prototype.bubbleSort = function () {for (let i = 0; i < this.length - 1; i += 1) {for (let j = 0; j < this.length - 1 - i; j += 1) {if (this[j] > this[j + 1]) {const temp = this[j];this[j] = this[j + 1];this[j + 1] = temp;}}} };const arr = [5, 4, 3, 2, 1]; arr.bubbleSort();

時間復雜度O(n^2)

Javascript實現：選擇排序

選擇排序的思路
找到數組中的最小值，選中它并將其放置在第一位
接著找到第二小的值，選中它并將其放置在第二位
以此類推，執行n - 1輪

Array.prototype.selectionSort = function () {for (let i = 0; i < this.length - 1; i += 1) {let indexMin = i;for (let j = i; j < this.length; j += 1) {if (this[j] < this[indexMin]) {indexMin = j;}}if (indexMin !== i) {const temp = this[i];this[i] = this[indexMin];this[indexMin] = temp;}} };const arr = [5, 4, 3, 2, 1]; arr.selectionSort();

時間復雜度O(n^2)

Javascript實現：插入排序

插入排序的思路
從第二個數開始往前比
比它大就往后排
以此類推進行到最后一個數

Array.prototype.insertionSort = function () {for (let i = 1; i < this.length; i += 1) {const temp = this[i];let j = i;while (j > 0) {if (this[j - 1] > temp) {this[j] = this[j - 1];} else {break;}j -= 1;}this[j] = temp;} };const arr = [2, 4, 5, 3, 1]; arr.insertionSort();

時間復雜度O(n^2)

Javascript實現：歸并排序

歸并排序的思路
分：把數組劈成兩半，再遞歸地對子數組進行“分操作”，直到分成一個個單獨的數
合：把兩個數合并為有序數組，再對有序數組進行合并，直到全部子數組合并成一個完整數組
合并兩個有序數組
新建一個空數組res，用于存放最終排序后的數組
比較兩個有序數組的頭部，較小者出隊并推入res中
如果兩個數組還有值，就重復第二步

Array.prototype.mergeSort = function () {const rec = (arr) => {if (arr.length === 1) { return arr; }const mid = Math.floor(arr.length / 2);const left = arr.slice(0, mid);const right = arr.slice(mid, arr.length);const orderLeft = rec(left);const orderRight = rec(right);const res = [];while (orderLeft.length || orderRight.length) {if (orderLeft.length && orderRight.length) {res.push(orderLeft[0] < orderRight[0] ? orderLeft.shift() : orderRight.shift());} else if (orderLeft.length) {res.push(orderLeft.shift());} else if (orderRight.length) {res.push(orderRight.shift());}}return res;};const res = rec(this);res.forEach((n, i) => { this[i] = n; }); };const arr = [5, 4, 3, 2, 1]; arr.mergeSort();

分的時間復雜度是O(logN)
合的時間復雜度是O(n)
時間復雜度：O(n * logN)

Javascript實現：快速排序

快速排序的思路
分區：從數組中任意選擇一個“基準”，所有比基準小的元素放在基準前面，比基準大的元素放在基準的后面
遞歸：遞歸地對基準前后的子數組進行分區

Array.prototype.quickSort = function () {const rec = (arr) => {if (arr.length === 1) { return arr; }const left = [];const right = [];const mid = arr[0];for (let i = 1; i < arr.length; i += 1) {if (arr[i] < mid) {left.push(arr[i]);} else {right.push(arr[i]);}}return [...rec(left), mid, ...rec(right)];};const res = rec(this);res.forEach((n, i) => { this[i] = n }); };const arr = [2, 4, 5, 3, 1]; arr.quickSort();

遞歸的時間復雜度是O(logN)
分區操作的時間復雜度是O(n)
時間復雜度：O(n * logN)

Javascript實現：順序搜索

順序搜索的思路
遍歷數組
找到跟目標值相等的元素，就返回它的下標
遍歷結束后，如果沒有搜索到目標值，就返回-1

Array.prototype.sequentialSearch = function (item) {for (let i = 0; i < this.length; i += 1) {if (this[i] === item) {return i;}}return -1; };const res = [1, 2, 3, 4, 5].sequentialSearch(0);

時間復雜度O(n)

Javascript實現：二分搜索

二分搜索前提是數組是有序的
二分搜索的思路
從數組的中間元素開始，如果中間元素正好是目標值，則搜索結束
如果目標值大于或者小于中間元素，則在大于或小于中間元素的那一半數組中搜索

Array.prototype.binarySearch = function (item) {let low = 0;let high = this.length - 1;while (low <= high) {const mid = Math.floor((low + high) / 2);const element = this[mid];if (element < item) {low = mid + 1;} else if (element > item) {high = mid - 1;} else {return mid;}}return -1; };const res = [1, 2, 3, 4, 5].binarySearch(0);

每一次比較都使搜索范圍縮小一半，時間復雜度O(logN)

LeetCode：21.合并兩個有序鏈表

解題思路
與歸并排序中的合并兩個有序數組很相似
將數組替換成鏈表就能解此題
解題步驟
新建一個新鏈表，作為返回結果
用指針遍歷兩個有序鏈表，并比較兩個鏈表的當前節點，較小者先接入新鏈表，并將指針后移一步
鏈表遍歷結束，返回新鏈表

時間復雜度O(n)，n是兩個鏈表長度之和，空間復雜度是O(1)

LeetCode：374.猜數字大小

解題思路
這不就是二分搜索嘛
調用guess函數，來判斷中間元素是否是目標值
解題步驟
從數組的中間元素開始，如果中間元素正好是目標值，則搜索過程結束
如果目標值大于或者小于中間元素，則在數組大于或小于中間元素的那一半中查找

時間復雜度O(logn)，空間復雜度是O(1)

思考題

1、Chrome 最新的 Array.prototype.sort 用的是什么排序算法？
2、用二分搜索算法求 x 的平方根。題目鏈接：https://leetcode-cn.com/problems/sqrtx/

總結

以上是生活随笔為你收集整理的（十一）进阶算法之“搜索排序”的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。