JavaScript實現排序演算法
阿新 • • 發佈：2020-03-20
## JavaScript實現排序演算法
### 一、大O表示法
**大O表示法：**
* 在計算機中採用**粗略的度量**來描述計算機演算法的**效率**，這種方法被稱為**“大O”表示法**
* 在**資料項個數**發生改變時，**演算法的效率**也會跟著改變。所以說演算法A比演算法B快兩倍，這樣的比較是**沒有意義**的。
* 因此我們通常使用**演算法的速度**隨著**資料量的變化**會如何變化的方式來表示演算法的效率，大O表示法就是方式之一。
**常見的大O表示形式**
| 符號 | 名稱 |
| ------------ | -------------- |
| O（1） | 常數 |
| O（log(n)） | 對數 |
| O（n） | 線性 |
| O（nlog(n)） | 線性和對數乘積 |
| O（n²） | 平方 |
| O（2^n^） | 指數 |
**不同大O形式的時間複雜度：**
可以看到效率從大到小分別是：O（1）> O（logn）> O（n）> O（nlog(n)）> O（n²）> O（2^n^）
**推導大O表示法的三條規則：**
* **規則一**：用常量1取代執行時間中所有的加法常量。如7 + 8 = 15，用1表示運算結果15，大O表示法表示為O（1）；
* **規則二**：運算中只保留最高階項。如N^3 + 3n +1，大O表示法表示為：O（N^3^）;
* **規則三**：若最高階項的常數不為1，可將其省略。如4N^2^，大O表示法表示為：O（N^2^）;
### 二、排序演算法
這裡主要介紹幾種簡單排序和高階排序：
* **簡單排序：**氣泡排序、選擇排序、插入排序；
* **高階排序：**希爾排序、快速排序；
此處建立一個列表類ArrayList並新增一些屬性和方法，用於存放這些排序方法：
```
//建立列表類
function ArrayList() {
//屬性
this.array = []
//方法
//封裝將資料插入到陣列中方法
ArrayList.prototype.insert = function(item){
this.array.push(item)
}
//toString方法
ArrayList.prototype.toString = function(){
return this.array.join('-')
}
//交換兩個位置的資料
ArrayList.prototype.swap = function(m, n){
let temp = this.array[m]
this.array[m] = this.array[n]
this.array[n] = temp
}
```
#### 1.氣泡排序
**氣泡排序的思路：**
* 對未排序的各元素**從頭到尾**依次比較**相鄰的兩個元素**大小關係；
* 如果**左邊的人員高**，則將兩人**交換位置**。比如1比2矮，不交換位置；
* 向**右移動一位**，繼續比較2和3，最後比較 length - 1 和 length - 2這兩個資料；
* 當到達**最右端**時，**最高的人**一定被放在了**最右邊**；
* 按照這個思路，從最左端重新開始時，只需要走到**倒數第二個位置**即可；
**實現思路：**
兩層迴圈：
* 外層迴圈控制冒泡趟數：
* 第一次：j = length - 1，比較到倒數第一個位置 ；
* 第二次：j = length - 2，比較到倒數第二個位置 ；
* 內層迴圈控制每趟比較的次數：
* 第一次比較： i = 0，比較 0 和 1 位置的兩個資料；
* 最後一次比較：i = length - 2,比較length - 2和 length - 1兩個資料；
詳細過程如下圖所示：
動態過程：
**程式碼實現：**
``` //氣泡排序
//氣泡排序
ArrayList.prototype.bubblesor = function(){
//1.獲取陣列的長度
let length = this.array.length
//外層迴圈控制冒泡趟數
for(let j = length - 1; j >= 0; j--){
//內層迴圈控制每趟比較的次數
for(let i = 0; i < j; i++){
if (this.array[i] > this.array[i+1]) {
//交換兩個資料
let temp = this.array[i]
this.array[i] = this.array[i+1]
this.array[i+1] = temp
}
}
}
}
```
**測試程式碼：**
```
//測試類
let list = new ArrayList()
//插入元素
list.insert(66)
list.insert(88)
list.insert(12)
list.insert(87)
list.insert(100)
list.insert(5)
list.insert(566)
list.insert(23)
//驗證氣泡排序
list.bubblesor()
console.log(list);
```
**測試結果：**
**氣泡排序的效率：**
* 上面所講的對於7個數據項，比較次數為：6 + 5 + 4 + 3 + 2 + 1;
* 對於N個數據項，**比較次數**為：(N - 1) + (N - 2) + (N - 3) + ... + 1 = N * (N - 1) / 2；如果兩次比較交換一次，那麼**交換次數**為：N * (N - 1) / 4；
* 使用大O表示法表示比較次數和交換次數分別為：O（ N * (N - 1) / 2）和O（ N * (N - 1) / 4），根據大O表示法的三條規則都化簡為：**O（N^2）**;
#### 2.選擇排序
**選擇排序改進了氣泡排序：**
* 將**交換次數**由**O（N^2）**減小到**O（N）**；
* 但是**比較次數**依然是**O（N^2）**；
**選擇排序的思路：**
* 選定**第一個索引的位置**比如1，然後依次和後面的元素**依次進行比較**；
* 如果後面的元素，**小於**索引1位置的元素，則**交換位置**到索引1處；
* 經過一輪的比較之後，可以確定一開始指定的索引1位置的元素是**最小的**；
* 隨後使用同樣的方法除索引1意外**逐個比較剩下的元素**即可；
* 可以看出選擇排序，**第一輪**會選出**最小值**，**第二輪**會選出**第二小的值**，直到完成排序。
**實現思路：**
兩層迴圈：
* 外層迴圈控制指定的索引：
* 第一次：j = 0，指定第一個元素 ；
* 最後一次：j = length - 1，指定最後一個元素 ；
* 內層迴圈負責將指定索引（i）的元素與剩下（i - 1）的元素進行比較；
動態過程：
**程式碼實現：**
```
//選擇排序
ArrayList.prototype.selectionSort = function(){
//1.獲取陣列的長度
let length = this.array.length
//2.外層迴圈：從0開始獲取元素
for(let j = 0; j < length - 1; j++){
let min = j
//內層迴圈：從i+1位置開始，和後面的元素進行比較
for(let i = min + 1; i < length; i++){
if (this.array[min] > this.array[i]) {
min = i
}
}
this.swap(min, j)
}
}
```
**測試程式碼：**
```
//測試類
let list = new ArrayList()
//插入元素
list.insert(66)
list.insert(88)
list.insert(12)
list.insert(87)
list.insert(100)
list.insert(5)
list.insert(566)
list.insert(23)
//驗證選擇排序
list.selectionSort()
console.log(list);
```
**測試結果：**
**選擇排序的效率：**
* 選擇排序的**比較次數**為：N * (N - 1) / 2，用大O表示法表示為：**O（N^2）**;
* 選擇排序的**交換次數**為：(N - 1) / 2，用大O表示法表示為：**O（N）**;
* 所以選擇排序的效率高於氣泡排序；
#### 3.插入排序
插入排序是簡單排序中效率**最高**的一種排序。
**插入排序的思路：**
* 插入排序思想的核心是**區域性有序**。如圖所示，X左邊的人稱為**區域性有序**；
* 首先指定一資料X（從第一個資料開始），並將資料X的左邊變成區域性有序狀態；
* 隨後將X右移一位，再次達到區域性有序之後，繼續右移一位，重複前面的操作直至X移至最後一個元素。
插入排序的詳細過程：
動態過程：
**程式碼實現：**
```
//插入排序
ArrayList.prototype.insertionSort = function(){
//1.獲取陣列的長度
let length = this.array.length
//2.外層迴圈:從第二個資料開始，向左邊的已經區域性有序資料進行插入
for(let i = 1; i < length; i++){
//3.內層迴圈：獲取i位置的元素，使用while迴圈(重點)與左邊的區域性有序資料依次進行比較
let temp = this.array[i]
let j = i
while(this.array[j - 1] >