目錄

• • • 1 插入排序
    • 2 堆排序
    • 3 歸并排序
    • 4 快速排序
    • 5 冒泡排序
    • 6 選擇排序

1 插入排序

時間復雜度$O(n^2)$ 空間復雜度 O(1) 穩定

從第一個元素開始，認為左邊的序列是有序的，從有序部分的最后一個向前比較，如果當前元素小于有序部分就交換，否則比較下一個元素。

function insertMerge(arr) {for(let i = 1; i < arr.length; i++) {let target = ifor (let j = i-1; j >= 0; j--) {if (arr[target] < arr[j]) { // 無序 交換元素[arr[target], arr[j]] = [arr[j], arr[target]]target = j // 交換之后target變為j} else {break // 有序 直接i++}}}return arr } let arr = [1,5,2,4,3,6,8,7] console.log(insertMerge(arr));

2 堆排序

時間復雜度$O(n)$ 空間復雜度 O(1) 不穩定

先建堆，然后每次讓數組的最后一個元素和第一個元素進行交換，交換之后調整堆。注意每一輪交換之后找到一個最大值放在了原數組的末尾，下次交換這個元素不參與，相當于原數組長度-1。

建堆是從最后一個非葉子節點開始也就是 (len/2-)1，依次向上調整

調整的過程是拿目標節點和兩個子節點中最大的值比較，如果子節點大就交換，目標節點變成較大的子節點，否則，已符合堆結構，進行下一輪調整。

/*** 完全二叉樹的最后一個非葉子節點是 Math.floor(len/2)-1* 孩子節點的 2*i+1 和 2*i+2*/ function heapSort(arr) {// 建堆 找到一個最大值createHeap(arr, 0, arr.length)// console.log(arr);// 每一輪跳過一個最后的最大值for (let i = arr.length-1; i >= 0; i--) {// 每次交換第一個元素和該輪數組的最后一個元素// 最后一個元素是最大值 下一輪只需要比較之前的序列 最后一個元素變成了i-1[arr[i], arr[0]] = [arr[0], arr[i]]// i 是數組的長度adjust(arr, 0, i)}return arr } function createHeap(arr) {const len = arr.length// 從最后一個非葉子節點開始調整const start = Math.floor(len/2)-1for(let i = start; i >= 0; i--) {adjust(arr, i, len)} } function adjust(arr, target, len) {for (let i = 2*target+1; i < len; i = i*2+1) {if (i + 1 < len && arr[i+1] > arr[i]) {i = i + 1}if (arr[target] < arr[i]) {[arr[target], arr[i]] = [arr[i], arr[target]]target = i} else {break}} }let arr = [1,3,2,5,3,6,2,0] console.log(heapSort(arr))

3 歸并排序

時間復雜度O(nlogn) 空間復雜度O(n) 穩定

分割
將數組從分成左右兩個數組，然后遞歸的分割，知道數組的長度小于2

合并
當左右兩個數組有序的時候，合并兩個數組。創建一個空數組temp，比較左右兩邊的數組，小值加入到temp中。若左右數組有一個為空，那么此時另一個數組一定大于temp中的所有元素，直接將其所有元素加入temp。
然后將tmp的值一一傳遞給原數組

function mergeSort(arr, left, right, tmp) {if (left >= right) return arrconst mid = Math.floor((left+right)/2)mergeSort(arr, left, mid, tmp)mergeSort(arr, mid+1, right, tmp)merge(arr, left, right, tmp)return arr }function merge(arr, left, right, tmp) {const mid = Math.floor((left+right)/2)let leftIndex = leftlet rightIndex = mid + 1let tmpIndex = 0while (leftIndex <= mid && rightIndex <= right) {if (arr[leftIndex] < arr[rightIndex]) {tmp[tmpIndex++] = arr[leftIndex++]} else {tmp[tmpIndex++] = arr[rightIndex++]}}while (leftIndex <= mid) {tmp[tmpIndex++] = arr[leftIndex++]}while (rightIndex <= right) {tmp[tmpIndex++] = arr[rightIndex++]}tmpIndex = 0for (let i = left; i <= right; i++) {arr[i] = tmp[tmpIndex++]} }let arr = [3,4,2,1,5,0] mergeSort(arr, 0, arr.length-1, []) console.log(arr)

4 快速排序

時間復雜度：平均O(nlogn)，最壞$O(n^2)$，實際上大多數情況下小于O(nlogn)

空間復雜度:O(logn)（遞歸調用消耗）

快速排序是每次找到一個基準元素，左右兩邊分別和基準元素比較，如果左邊元素小于基準元素，左指針向右移動，如果右邊元素大于基元素，右指針向左移動。否則，就交換左右兩邊的元素。當左右指針相遇，相遇處即是基準元素所在的位置，將基準元素交換到該位置。基準元素切分出了左右兩邊，左邊都比基準元素小，右邊都比基準元素大。

function quickSort(arr, left, right) {if (left >= right) returnlet i = left, j = right, pivot = arr[left]while (i < j) {while (i < j && arr[j] >= pivot) {j--}while (i < j && arr[i] <= pivot) {i++}swap(arr, i, j)}swap(arr, left, i)quickSort(arr, left, i-1)quickSort(arr, i+1, right) }function swap(arr, i, j) {const tmp = arr[i]arr[i] = arr[j]arr[j] = tmp }const arr = [3,2,4,1,5,6,8] quickSort(arr, 0, arr.length-1) console.log(arr)

5 冒泡排序

時間復雜度$O(n^2)$ 空間復雜度O(1) 不穩定
每次將一個最大值沉底，下一次比較不考慮沉底的元素

function bubble(arr) {const len = arr.length// 將第i個最大值沉底for (let i = 0; i < len; i++) {// 排除沉底元素 進行比較for (let j = 0; j < len-i-1; j++) {// 比較的是內層循環if (arr[j+1] < arr[j]) {[arr[j+1], arr[j]] = [arr[j], arr[j+1]]}}}return arr } const arr = [4,5,2,1,3] bubble(arr) console.log(arr)

6 選擇排序

時間復雜度$O(n^2)$ 空間復雜度O(1) 不穩定

每次選出最小的元素放在未排序的部分的首位

/*** 每次選出最小的元素放在首位*/ function selectSort(arr) {const len = arr.lengthlet minIndexfor (let i = 0; i < len; i++) {minIndex = ifor (let j = i+1; j < len; j++) {if(arr[minIndex] > arr[j]) {minIndex = j}}[arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]} }const arr = [1,3,2,1,5,6,7] selectSort(arr) console.log(arr)

總結

以上是生活随笔為你收集整理的【手撕算法】排序的全部內容，希望文章能夠幫你解決所遇到的問題。

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