算法是什么？、

算法（Algorithm）?代表著用系統(tǒng)的方法描述解決問題的策略機制，可以通過一定規(guī)范的?輸入，在有限時間內獲得所需要的?輸出。

一個算法的好壞是通過?時間復雜度?與?空間復雜度?來衡量的。

簡單來說，時間復雜度?就是執(zhí)行算法的?時間成本?，空間復雜度?則是執(zhí)行算法的?空間成本?。

時間復雜度?與?空間復雜度?都是用?“大O”?來表示，寫作?O(*)。有一點值得注意的是，我們談論復雜度，一般談論的都是時間復雜度。

常見時間復雜度的?“大O表示法”?描述有以下幾種：

時間復雜度非正式術語

O(1)	常數(shù)階
O(n)	線性階
O(n2)	平方階
O(log n)	對數(shù)階
O(n log n)	線性對數(shù)階
O(n3)	立方階
O(2n)	指數(shù)階

一個算法在N規(guī)模下所消耗的時間消耗從大到小如下：

O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(n³) < O(2ⁿ)

常見的排序算法

1.O(n2)?的排序算法

• 冒泡排序

• 選擇排序

• 插入排序

• 希爾排序

2.O(n log n)?的排序算法

• 歸并排序

• 快速排序

• 堆排序

3.線性的排序算法

• 計數(shù)排序

• 桶排序

• 基數(shù)排序

冒泡排序

冒泡排序之所以叫冒泡排序，是因為它每一種元素都像小氣泡一樣根據(jù)自身大小一點一點往數(shù)組的一側移動。

算法步驟如下：

比較相鄰的元素。如果第一個比第二個大，就交換他們兩個；

對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大的數(shù)；

針對所有的元素重復以上的步驟，除了最后一個；

持續(xù)每次對越來越少的元素重復上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。

const?bubbleSort?=?arr?=>?{
????const?len?=?arr.length?-?1
????for?(let?i?=?0;?i?<?len;?++i)?{?/*?外循環(huán)為排序趟數(shù)，len個數(shù)進行l(wèi)en-1趟?*/
????????for?(let?j?=?0;?j?<?len?-?i;?++j)?{?/*?內循環(huán)為每趟比較的次數(shù)，第i趟比較len-i次?*/
????????????if?(arr[j]?>?arr[j?+?1])?{?/*?相鄰元素比較，若逆序則交換（升序為左大于右，逆序反之）?*/
????????????????[arr[j],?arr[j?+?1]]?=?[arr[j?+?1],?arr[j]]
????????????}
????????}
????}
????return?arr
}

選擇排序（Selection sort）?是一種簡單直觀的排序算法。

選擇排序的主要優(yōu)點與數(shù)據(jù)移動有關。

如果某個元素位于正確的最終位置上，則它不會被移動。

選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，因此對?n?個元素的表進行排序總共進行至多?n - 1?次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序屬于非常好的一種。

選擇排序的算法步驟如下：

在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；

然后，再從剩余未排序元素中繼續(xù)尋找最小（大）元素，然后放到已排序序列的末尾；

以此類推，直到所有元素均排序完畢。

代碼實現(xiàn)：

? ??const?selectionSort?=?arr?=>?{
????const?len?=?arr.length
????let?min
????for?(let?i?=?0;?i?<?len?-?1;?++i)?{
????????min?=?i?/*?初始化未排序序列中最小數(shù)據(jù)數(shù)組下標?*/
????????for?(let?j?=?i?+?1;?j?<?len;?++j)?{?/*?訪問未排序的元素?*/
????????????if?(arr[j]?<?arr[min])?{?/*?找到目前最小值?*/
????????????????min?=?j?/*?記錄最小值?*/
????????????}
????????}
????????[arr[i],?arr[min]]?=?[arr[min],?arr[i]]?/*?交換位置?*/
????}
????return?arr
}

插入排序

插入排序（Selection sort）?是一種簡單直觀的排序算法。

它的工作原理是通過構建有序序列，對于未排序數(shù)據(jù)，在已排序序列中從后向前掃描，找到相應位置并插入。

插入排序的算法步驟如下：

從第一個元素開始，該元素可以認為已經(jīng)被排序；

取出下一個元素，在已經(jīng)排序的元素序列中從后向前掃描；

如果該元素（已排序）大于新元素，將該元素移到下一位置；

重復步驟3，直到找到已排序的元素小于或者等于新元素的位置；

將新元素插入到該位置后；

重復步驟2~5。

const?insertionSort?=?arr?=>?{
????const?len?=?arr.length
????let?j,?temp
????for?(let?i?=?0;?i?<?len;?++i)?{
????????j?=?i?/*?存儲當前索引，便于后續(xù)與數(shù)組其他元素對比?*/
????????while?(j?>?0?&&?arr[j?-?1]?>?temp)?{
????????????arr[j]?=?arr[j?-?1]
????????????j--
????????}
????????[arr[j],?arr[i]]?=?[arr[i],?arr[i]]
????}
????return?arr
}

希爾排序

希爾排序，也稱?遞減增量排序算法，是?插入排序?的一種更高效的改進版本。希爾排序是非穩(wěn)定排序算法。

希爾排序是基于插入排序的以下兩點性質而提出改進方法的：

插入排序在對幾乎已經(jīng)排好序的數(shù)據(jù)操作時，效率高，即可以達到?線性排序?的效率；

但插入排序一般來說是低效的，因為插入排序每次只能將數(shù)據(jù)移動一位。

步長的選擇是希爾排序的重要部分。

只要最終步長為1任何步長序列都可以工作。

算法最開始以一定的步長進行排序。

然后會繼續(xù)以一定步長進行排序，最終算法以步長為1進行排序。

當步長為1時，算法變?yōu)槠胀ú迦肱判?#xff0c;這就保證了數(shù)據(jù)一定會被排序。

插入排序的算法步驟如下：

定義一個用來分割的步長；

按步長的長度K，對數(shù)組進行K趟排序；

不斷重復上述步驟。

const?shellSort?=?arr?=>?{
????let?gaps?=?[5,?3,?1]?//?定義步長以及分割次數(shù)
????let?len?=?arr.length
????for?(let?g?=?0,?gLen?=?gaps.length;?g?<?gaps.length;?++g)?{
????????for?(let?i?=?gaps[g];?i?<?len;?++i)?{
????????????let?j
????????????for?(j?=?i;?j?>=?gaps[g]?&&?arr[j?-?gaps[g]]?>?arr[i];?j?-=?gaps[g])?{
????????????????arr[j]?=?arr[j?-?gaps[g]]
????????????}
????????????[arr[i],?arr[j]]?=?[arr[j],?arr[i]]
????????}
????}
????return?arr
}

快速排序

快速排序（Quicksort），又稱?劃分交換排序（partition-exchange sort）?。

快速排序（Quicksort）?在平均狀況下，排序?n?個項目要?O(n log n)?次比較。在最壞狀況下則需要?O(n²)?次比較，但這種狀況并不常見。事實上，快速排序?O(n log n)?通常明顯比其他算法更快，因為它的?內部循環(huán)（inner loop）?可以在大部分的架構上很有效率地達成。

快速排序使用?分治法（Divide and conquer）?策略來把一個序列分為較小和較大的2個子序列，然后遞歸地排序兩個子序列。

快速排序的算法步驟如下：

挑選基準值：從數(shù)列中挑出一個元素，稱為?“基準”（pivot）?；

分割：重新排序序列，所有比基準值小的元素擺放在基準前面，所有比基準值大的元素擺在基準后面（與基準值相等的數(shù)可以到任何一邊）。在這個分割結束之后，對基準值的排序就已經(jīng)完成；

遞歸排序子序列：遞歸地將小于基準值元素的子序列和大于基準值元素的子序列排序。

遞歸到最底部的判斷條件是序列的大小是零或一，此時該數(shù)列顯然已經(jīng)有序。

選取基準值有數(shù)種具體方法，此選取方法對排序的時間性能有決定性影響。

const?quickSort?=?arr?=>?{
????const?len?=?arr.length
????if?(len?<?2)?{
????????return?arr
????}
????const?pivot?=?arr[0]
????const?left?=?[]
????const?right?=?[]
????for?(let?i?=?1;?i?<?len;?++i)?{
????????if?(arr[i]?>=?pivot)?{
????????????right.push(arr[i])
????????}
????????if?(arr[i]?<?pivot)?{
????????????left.push(arr[i])
????????}
????}
????return?[...quickSort(left),?pivot,?...quickSort(right)]
}

三路快排

const?quickSort?=?arr?=>?{
????const?len?=?arr.length
????if?(len?<?2)?{
????????return?arr
????}
????let?left?=?[]
????let?center?=?[]
????let?right?=?[]
????let?pivot?=?arr[0]
????for?(let?i?=?0;?i?<?len;?++i)?{??????
????????if?(arr[i]?<?pivot)?{
????????????left.push(arr[i])
????????}?else?if?(arr[i]?===?pivot)?{
????????????center.push(arr[i])
????????}?else?{
????????????right.push(arr[i])
????????}
????}
????return?[...quickSort(left),?...center,?...quickSort(right)]
}

歸并排序

第一種是?自上而下的遞歸?，算法步驟如下：

申請空間，使其大小為兩個已經(jīng)排序序列之和，該空間用來存放合并后的序列；

設定兩個指針，最初位置分別為兩個已經(jīng)排序序列的起始位置；

比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置；

重復步驟3直到某一指針到達序列尾；

將另一序列剩下的所有元素直接復制到合并序列尾。

具體實現(xiàn)：

?

?

?

?

?

?

?

?

?

?

const?merge?=?(left,?right)?=>?{
????let?resArr?=?[]
????while?(left.length?&&?right.length)?{
????????if?(left[0]?<?right[0])?{
????????????resArr.push(left.shift())
????????}?else?{
????????????resArr.push(right.shift())
????????}
????}
????return?resArr.concat(left,?right)
}

const?mergeSort?=?arr?=>?{
????if?(arr.length?<=?1)?{
????????return?arr
????}
????let?middle?=?Math.floor(arr.length?/?2)
????let?left?=?arr.slice(0,?middle)
????let?right?=?arr.slice(middle)
????return?merge(mergeSort(left),?mergeSort(right))
}

自下而上的迭代?，由于?分治法?的具體算法基本都能用?遞歸?跟?迭代?來實現(xiàn)，所有才有這種寫法，其主要步驟如下：

將序列每相鄰兩個數(shù)字進行?歸并操作?，形成?ceil(n / 2)?個序列，排序后每個序列包含兩/一個元素；

若此時序列數(shù)不是1個則將上述序列再次歸并，形成?ceil(n / 4)??個序列，每個序列包含四/三個元素；

重復步驟2，直到所有元素排序完畢，即序列數(shù)為1。

具體實現(xiàn)如下：

const?merge?=?(arr,?startLeft,?stopLeft,?startRight,?stopRight)?=>?{
????/*?建立左右子序列?*/
????let?rightArr?=?new?Array(stopRight?-?startRight?+?1)
????let?leftArr?=?new?Array(stopLeft?-?startLeft?+?1)
????/*?給左右序列排序?*/
????let?k?=?startRight
????for?(let?i?=?0,?len?=?rightArr.length;?i?<?len?-?1;?++i)?{
????????rightArr[i]?=?arr[k]
????????++k
????}
????k?=?startLeft
????for?(let?i?=?0,?len?=?leftArr.length;?i?<?len?-?1;?++i)?{
????????leftArr[i]?=?arr[k]
????????++k
????}
????//設置哨兵值，當左子列或右子列讀取到最后一位時，即Infinity，可以讓另一個剩下的列中的值直接插入到數(shù)組中
????rightArr[rightArr.length?-?1]?=?Infinity
????leftArr[leftArr.length?-?1]?=?Infinity
????let?m?=?0
????let?n?=?0
????//?比較左子列和右子列第一個值的大小，小的先填入數(shù)組，接著再進行比較
????for?(let?c?=?startLeft;?c?<?stopRight;?++c)?{
????????if?(leftArr[m]?<=?rightArr[n])?{
????????????arr[c]?=?leftArr[m]
????????????m++
????????}?else?{
????????????arr[c]?=?rightArr[n]
????????????n++
????????}
????}
}
const?mergeSort?=?arr?=>?{
????if?(arr.length?<=?1)?{
????????return?arr
????}
????//設置子序列的大小
????let?step?=?1
????let?left
????let?right
????while?(step?<?arr.length)?{
????????left?=?0
????????right?=?step
????????while?(right?+?step?<=?arr.length)?{
????????????merge(arr,?left,?left?+?step,?right,?right?+?step)
????????????left?=?right?+?step
????????????right?=?left?+?step
????????}
????????if?(right?<?arr.length)?{
????????????merge(arr,?left,?left?+?step,?right,?arr.length)
????????}
????????step?*=?2
????}
????return?arr
}

魚頭注：迭代比起遞歸還是安全很多，太深的遞歸容易導致堆棧溢出。

堆排序

堆排序的算法步驟如下：

把無序數(shù)列構建成二叉堆；

循環(huán)刪除堆頂元素，替換到二叉堆的末尾，調整堆產(chǎn)生新的堆頂。

/*?堆下沉調整?*/
const?adjustHeap?=?(arr,?parentIndex,?length)?=>?{
????let?temp?=?arr[parentIndex]?/*?temp保存父節(jié)點值，用于最后賦值?*/
????let?childIndex?=?2?*?parentIndex?+?1?/*?保存子節(jié)點位置?*/
????while?(childIndex?<?length)?{
????????/*?如果有右子節(jié)點，且右子節(jié)點大于左子節(jié)點的值，則定位到右子節(jié)點?*/
????????if?(childIndex?+?1?<?length?&&?arr[childIndex?+?1]?>?arr[childIndex])?{
????????????childIndex++
????????}
????????/*?如果父節(jié)點小于任何一個子節(jié)點的值，直接退出循環(huán)?*/
????????if?(temp?>=?arr[childIndex])?{
????????????break;
????????}
????????/*?無序交換，單向賦值即可?*/
????????arr[parentIndex]?=?arr[childIndex]
????????parentIndex?=?childIndex
????????childIndex?=?2?*?childIndex?+?1
????}
????arr[parentIndex]?=?temp
}
const?heapSort?=?arr?=>?{
????/*?把無序數(shù)列構建成最大堆?*/
????for?(let?i?=?Math.floor(arr.length?/?2);?i?>=?0;?--i)?{
????????adjustHeap(arr,?i,?arr.length?-?1)
????}
????for?(let?i?=?arr.length?-?1;?i?>?0;?--i)?{
????????/*?交換最后一個元素與第一個元素?*/
????????[arr[i],?arr[0]]?=?[arr[0],?arr[i]]
????????/*?調整最大堆?*/
????????adjustHeap(arr,?0,?i)
????}
????return?arr
}

計數(shù)排序

計數(shù)排序（Counting sort）?是一種穩(wěn)定的線性時間排序算法。該算法于1954年由 Harold H. Seward 提出。計數(shù)排序使用一個額外的數(shù)組來存儲輸入的元素，計數(shù)排序要求輸入的數(shù)據(jù)必須是有確定范圍的整數(shù)。

當輸入的元素是?n?個?0?到?k?之間的整數(shù)時，它的運行時間是?O(n + k)?。計數(shù)排序不是比較排序，排序的速度快于任何比較排序算法。

計數(shù)排序的算法步驟如下：

找出待排序的數(shù)組中最大和最小的元素；

統(tǒng)計數(shù)組中每個值為?i?的元素出現(xiàn)的次數(shù)，存入數(shù)組?C?的第?i?項；

對所有的計數(shù)累加（從數(shù)組?C?中的第一個元素開始，每一項和前一項相加）；

反向填充目標數(shù)組：將每個元素?i?放在新數(shù)組的第?C[i]?項，每放一個元素就將 C[i] 減去1

具體實現(xiàn)如下：

const?countSort?=?arr?=>?{
????const?C?=?[]
????for?(let?i?=?0,?iLen?=?arr.length;?i?<?iLen;?++i)?{
????????const?j?=?arr[i]
????????if?(C[j]?>=?1)?{
????????????C[j]++
????????}?else?{
????????????C[j]?=?1
????????}
????}
????const?D?=?[]
????for?(let?j?=?0,?jLen?=?C.length;?j?<?jLen;?++j)?{
????????if?(C[j])?{
????????????while?(C[j]?>?0)?{
????????????????D.push(j)
????????????????C[j]--
????????????}
????????}
????}
????return?D
}

桶排序（Bucket Sort）?跟?計數(shù)排序（Counting sort）?一樣是一種穩(wěn)定的線性時間排序算法，不過這次需要的輔助不是計數(shù)，而是桶。

工作的原理是將數(shù)列分到有限數(shù)量的桶里。每個桶再個別排序。當要被排序的數(shù)組內的數(shù)值是均勻分配的時候，桶排序使用線性時間?O(n)。

桶排序的算法步驟如下：

設置一個定量的數(shù)組當作空桶子；

尋訪序列，并且把項目一個一個放到對應的桶子去；

對每個不是空的桶子進行排序；

從不是空的桶子里把項目再放回原來的序列中。

const?bucketSort?=?arr?=>?{
????let?bucketsCount?=?10?/*?默認桶的數(shù)量?*/
????const?max?=?Math.max(...arr)?/*?序列最大數(shù)字?*/
????const?min?=?Math.min(...arr)?/*?數(shù)列最小數(shù)字?*/
????const?bucketsSize?=?Math.floor((max?-?min)?/?bucketsCount)?+?1?/*?桶的深度?*/
????const?__buckets?=?[]?/*?空桶?*/
????for?(let?i?=?0,?len?=?arr.length;?i?<?len;?++i)?{
????????const?index?=?~~(arr[i]?/?bucketsSize)?/*?騷操作，取數(shù)列中最大或最小的序列?*/
????????if?(!__buckets[index])?{
????????????__buckets[index]?=?[]?/*?創(chuàng)建子桶?*/
????????}
????????__buckets[index].push(arr[i])
????????let?bLen?=?__buckets[index].length
????????while?(bLen?>?0)?{?/*?子桶排序?*/
????????????if?(__buckets[index][bLen]?<?__buckets[index][bLen?-?1])?{
????????????????[__buckets[index][bLen],?__buckets[index][bLen?-?1]]?=?[__buckets[index][bLen?-?1],?__buckets[index][bLen]]
????????????}
????????????bLen--
????????}
????}
????let?buckets?=?[]?/*?真實序列?*/
????for?(let?i?=?0,?len?=?__buckets.length;?i?<?len;?++i)?{
????????if?(__buckets[i])?{
????????????buckets.push(...__buckets[i])
????????}
????}
????return?buckets
}

基數(shù)排序

基數(shù)排序（Radix sort）?是一種非比較型整數(shù)排序算法，其原理是將整數(shù)按位數(shù)切割成不同的數(shù)字，然后按每個位數(shù)分別比較。由于整數(shù)也可以表達字符串（比如名字或日期）和特定格式的浮點數(shù)，所以基數(shù)排序也不是只能使用于整數(shù)。

工作原理是將所有待比較數(shù)值（正整數(shù)）統(tǒng)一為同樣的數(shù)字長度，數(shù)字較短的數(shù)前面補零。然后，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成以后，數(shù)列就變成一個有序序列。

const?LSDRadixSort?=?arr?=>?{
????const?max?=?Math.max(...arr)?/*?獲取最大值?*/
????let?digit?=?`${max}`.length?/*?獲取最大值位數(shù)?*/
????let?start?=?1?/*?桶編號?*/
????let?buckets?=?[]?/*?空桶?*/
????while?(digit?>?0)?{
????????start?*=?10
????????/*?入桶?*/
????????for?(let?i?=?0,?len?=?arr.length;?i?<?len;?++i)?{
????????????const?index?=?(arr[i]?%?start)
????????????if?(!buckets[index])?{
????????????????buckets[index]?=?[]
????????????}
????????????buckets[index].push(arr[i])?/*?往不同桶里添加數(shù)據(jù)?*/
????????}
????????arr?=?[]
????????/*?出桶?*/
????????for(let?i?=?0;?i?<?buckets.length;?i++)?{
????????????if?(buckets[i])?{
????????????????arr?=?arr.concat(buckets[i])
????????????}
????????}
????????buckets?=?[]
????????digit?--
????}
????return?arr
}

雞尾酒排序，是?冒泡排序?的一種變形。此算法與?冒泡排序?不同的地方在于從低到高然后從高到低，而?冒泡排序?則僅從低到高去比較序列里的每個元素。它可以得到比?冒泡排序?稍微好一點的性能，原因是?冒泡排序?只從一個方向進行比對（由低到高），每次循環(huán)只移動一個項目。

步驟跟冒泡算法差不多，區(qū)別在于從起點到終點遍歷完之后會進行一次終點到起點的遍歷。

const?cocktailSort?=?arr?=>?{
????let?i
????let?left?=?0
????let?right?=?arr.length?-?1
????while?(left?<?right)?{
????????for?(i?=?left;?i?<?right;?++i)
????????????if?(arr[i]?>?arr[i?+?1])?{
????????????????[arr[i],?arr[i?+?1]]?=?[arr[i?+?1],?arr[i]]
????????????}
????????right--
????????for?(i?=?right;?i?>?left;?--i)
????????????if?(arr[i?-?1]?>?arr[i])?{
????????????????[arr[i],?arr[i?-?1]]?=?[arr[i?-?1],?arr[i]]
????????????}
????????left++
????}
????return?arr
}

?

轉載于:https://www.cnblogs.com/zhouyideboke/p/11164024.html

總結

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

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