javascript數據結構與算法--基本排序算法分析

時間 2019-11-17

標籤 javascript 數據結構算法基本排序算法分析欄目 JavaScript 简体版

原文原文鏈接

javascript中的基本排序算法javascript

對計算機中存儲的數據執行的兩種最多見操做是排序和檢索，排序和檢索算法對於前端開發尤爲重要，對此我會對這兩種算法作深刻的研究，而不會和書上同樣只是會貼代碼而已，下面我會一步步從本身的理解的思路來一步步學習各個排序的思想。不過這些算法依賴於javascript中的數組來存儲數據。最後我會來測試下基本算法(冒泡排序，選擇排序，插入排序)的那個效率更高！前端

下面啊，咱們先能夠來封裝常規數組操做的函數，好比：插入新數據，顯示數組數據，還有交換數組元素等操做來調用不一樣的排序算法。java

咱們先來封裝一個類 CArray，代碼以下：算法

function CArray(numElements) {
    this.dataStore = [];
    this.pos = 0;
    this.numElements = numElements;
    this.insert = insert;
    this.toString = toString;
    this.clear = clear;
    this.swap = swap;    
    for(var i = 0; i < numElements.length; i++) {
        this.dataStore[i] = numElements[i];
    }            
}

其中this.dataStore 是一個數組來保存數組中的全部元素，this.pos是一個索引值，默認爲0，從第一個開始，this.numElements是保存全部的數組元素，insert方法是向數組中插入一個元素的方法；toString是顯示數組中全部元素的方法；clear方法是清除數組中全部的元素，swap方法是交換數組中元素的位置的方法，此方法對排序頗有用處，下面咱們會用到他們。下面咱們來封裝下各個方法以下：chrome

function clear() {
    for(var i = 0; i < this.dataStore.length; i++) {
        this.dataStore[i] = 0;
    }
}
function insert(element) {
    this.dataStore[this.pos++] = element;
}
function toString() {
    var restr = "";
    for(var i = 0; i < this.dataStore.length; i++) {
        restr += this.dataStore[i] + " ";
        if(i > 0 && i % 10 == 0) {
            restr+= "\n";
        }
    }
    return restr;
}
function swap(arr,index1,index2) {
    var temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}

上面方法封裝先放在這裏，下面咱們先來研究下排序算法，稍後會使用到上面的方法。數組

一：冒泡排序：瀏覽器

冒泡排序在三種基本排序(冒泡排序，選擇排序，插入排序)中效率是最慢的一種排序算法；它的實現原理是：數組裏面的數據值會像氣泡同樣從數組的一端漂浮到另外一端。假設正在將一組數字按照升序排列，那麼較大的值會浮動到數組的右側，而較小的值會浮動到數組的左側。之因此會產生這種現象是由於算法會屢次在數組中移動，比較相鄰的數據，當左側值大於右側值時會將他們進行交換。dom

下面咱們先來看一下簡單的冒泡排序的demo以下：函數

E A D B H性能

通過第一次排序後，這個列表變成：

A E D B H

前2個元素進行了交換。接下來再次排序又會變成以下：

A D E B H

第二個和第三個元素進行了互換。繼續進行排序

A D B E H

第三個和第四個元素進行了互換，最後，第二個和第三個元素還會再次互換，獲得最終順序爲： A B D E H

下面咱們能夠來寫一個冒泡排序的函數 bubbleSort(),代碼以下：

function bubbleSort() {
    var numElements = this.dataStore.length;
    var temp;
    for(var outer = numElements; outer >= 2; --outer) {
        for(var inner = 0; inner <= outer -1; ++inner) {
            if(this.dataStore[inner] > this.dataStore[inner + 1]) {
                swap(this.dataStore,inner,inner+1);
            }
        }
    }
}

下面是全部的JS代碼以下

function CArray(numElements) {
    this.dataStore = [];
    this.pos = 0;
    this.numElements = numElements;
    this.insert = insert;
    this.toString = toString;
    this.clear = clear;
    this.swap = swap;
    this.bubbleSort = bubbleSort;
    for(var i = 0; i < numElements.length; i++) {
        this.dataStore[i] = numElements[i];
    }
            
    }
    function clear() {
        for(var i = 0; i < this.dataStore.length; i++) {
            this.dataStore[i] = 0;
        }
    }
    function insert(element) {
        this.dataStore[this.pos++] = element;
    }
    function toString() {
        var restr = "";
        for(var i = 0; i < this.dataStore.length; i++) {
            restr += this.dataStore[i] + " ";
            if(i > 0 && i % 10 == 0) {
                restr+= "\n";
            }
        }
        return restr;
    }
    function swap(arr,index1,index2) {
        var temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }
    function bubbleSort() {
        var numElements = this.dataStore.length;
        var temp;
        for(var outer = numElements; outer >= 2; --outer) {
            for(var inner = 0; inner <= outer -1; ++inner) {
                if(this.dataStore[inner] > this.dataStore[inner + 1]) {
                    swap(this.dataStore,inner,inner+1);
                }
            }
        }
    }

// 冒泡排序測試代碼
var numElements = [0,9,1,8,7,6,2,3,5,4];
var myNums = new CArray(numElements);
myNums.bubbleSort();
console.log(myNums.toString());

代碼分析以下：

假設數組爲 [0,9,1,8,7,6,2,3,5,4];

1. outer爲10的時候
1. inner爲0，值爲0，inner+1爲1，值爲9，不符合，不交換。
2. inner爲1，值爲9，inner+1爲2 值爲1，交換，數組變爲[0,1,9,8,7,6,2,3,5,4]
3. inner爲2，值爲9，inner+1爲3，值爲8，交換數組變爲[0,1,8,9,7,6,2,3,5,4]
4. inner爲3，值爲9，inner+1 爲4，值爲7，交換，數組變爲[0,1,8,7,9,6,2,3,5,4]
5, inner爲4，值爲9，inner+1 爲5，值爲6，交換，數組變爲 [0,1,8,7,6,9,2,3,5,4]
6. inner爲5，值爲9，inner+1 爲6，值爲2，交換，數組變爲[0,1,8,7,6,2,9,3,5,4]
7. inner爲6，值爲9，inner+1 爲7，值爲3，交換，數組變爲[0,1,8,7,6,2,3,9,5,4]
8. inner爲7，值爲9，inner+1 爲8，值爲5，交換，數組變爲[0,1,8,7,6,2,3,5,9,4]
9. inner爲8，值爲9，inner+1爲9，值爲4，交換，數組變爲[0,1,8,7,6,2,3,5,4,9]
10. inner爲9，值爲9，inner+1 不符合，不交換。

2. outer爲9的時候
1. inner爲0，值爲0，inner+1 不符合，不交換。
2. inner爲1 值爲1，inner+1值爲8 不符合不交換。
3. inner爲2 值爲8，inner+1值爲7，交換，數組變爲 [0,1,7,8,6,2,3,5,4,9]
4. inner爲3，值爲8，inner+1值爲6，交換，數組變爲[0,1,7,6,8,2,3,5,4,9]
5. inner爲4 值爲8 inner+1值爲2 交換數組變爲 [0,1,7,6,2,8,3,5,4,9]
6. inner爲5 值爲8，inner+1值爲3，交換，數組變爲[0,1,7,6,2,3,8,5,4,9]
7. inner爲6 值爲8，inner+1值爲5，交換數組變爲[0,1,7,6,2,3,5,8,4,9]
8. inner爲7 值爲8，inner+1值爲4，交換數組變爲[0,1,7,6,2,3,5,4,8,9]
9. inner爲8 值爲8，inner+1值爲9，不符合不交換。

3. outer爲8的時候
1. inner爲0，值爲0，inner+1 不符合，不交換。
2. inner爲1 值爲1，inner+1值爲7 不符合不交換。
3. inner爲2 值爲7，inner+1值爲6，交換數組變爲 [0,1,6,7,2,3,5,4,8,9]
4. inner爲3 值爲7，inner+1值爲2，交換，數組變爲[0,1,6,2,7,3,5,4,8,9]
5. inner爲4 值爲7，inner+1值爲3，交換，數組變爲[0,1,6,2,3,7,5,4,8,9]
6 inner爲5 值爲7 inner+1值爲5，交換，數組變爲[0,1,6,2,3,5,7,4,8,9]
7. inner爲6 值爲7 inner+1 值爲4，交換，數組變爲[0,1,6,2,3,5,4,7,8,9]
8. inner爲7 值爲7，inner+1值爲8，不符合。

4. outer爲7的時候
1. inner爲0，值爲0，inner+1 不符合，不交換。
2. inner爲1 值爲1，inner+1值爲6 不符合不交換。
3. inner爲2 值爲6，inner+1值爲2，交換數組變爲[0,1,2,6,3,5,4,7,8,9]
4. inner爲3 值爲6，inner+1值爲3，交換，數組變爲[0,1,2,3,6,5,4,7,8,9]
5 inner爲4 值爲6 inner+1值爲5，交換，數組變爲[0,1,2,3,5,6,4,7,8,9]
6 inner爲5 值爲6 inner+1值爲4，交換數組變爲[0,1,2,3,5,4,6,7,8,9]
7 inner爲6 值爲6，inner+1 值爲7，不符合。

5. outer爲6的時候
1. inner爲0，值爲0，inner+1 不符合，不交換。
2. inner爲1 值爲1，inner+1值爲2 不符合不交換。
3. inner爲2 值爲2，inner+1值爲3 不符合不交換。
4. inner爲3 值爲3，inner+1值爲5，不符合不交換。
5. inner爲4 值爲5，inner+1 值爲4 交換，數組變爲[0,1,2,3,4,5,6,7,8,9]

再下面繼續循環都不符合條件，因此如上就是最後一步了。這就是冒泡排序。

二：選擇排序

原理：選擇排序從數組的開頭開始，將第一個元素和其餘元素進行比較。檢查完全部元素後，最小的元素會被放到數組的第一個位置，而後算法會從第二個位置繼續。這個過程一直進行，當進行到數組的倒數第二個位置時，全部的數據便完成了排序。

選擇排序會用到嵌套循環。外循環從數組的第一個元素移動到倒數第二個元素，內循環從第二個數組元素移動到最後一個元素，查找比當前外循環所指向的元素小的元素。每次內循環迭代後，數組中最小的值都會被賦值到合適的位置。

如下是一個對只有五個元素的列表進行選擇排序的簡單列子，初始列表爲：

E A D H B

第一次排序會找到最小值，並將它和列表的第一個元素進行互換。

A E D H B

接下來查找第一個元素後面的最小值(第一個元素此時已經就位)，並對他們進行互換。

A B D H E

D也已經就位，所以下一步會對E和H進行互換，列表已按順序排好；

A B D E H

下面咱們就能夠來編寫選擇排序算法的selectionSort()方法了；以下代碼：

function selectionSort() {
    var min,temp;
    for(var outer = 0; outer <= this.dataStore.length -2; ++outer) {
        min = outer;
        for(var inner = outer + 1; inner <= this.dataStore.length - 1; ++inner) {
            if(this.dataStore[inner] < this.dataStore[min]) {
                swap(this.dataStore,inner,min); 
            }
        }
    }
}

下面是全部的JS代碼以下：

function CArray(numElements) {
    this.dataStore = [];
    this.pos = 0;
    this.numElements = numElements;
    this.insert = insert;
    this.toString = toString;
    this.clear = clear;
    this.swap = swap;
    this.selectionSort = selectionSort;    
    for(var i = 0; i < numElements.length; i++) {
        this.dataStore[i] = numElements[i];
    }        
}
        
function clear() {
    for(var i = 0; i < this.dataStore.length; i++) {
        this.dataStore[i] = 0;
    }
}
function insert(element) {
    this.dataStore[this.pos++] = element;
}
function toString() {
    var restr = "";
    for(var i = 0; i < this.dataStore.length; i++) {
        restr += this.dataStore[i] + " ";
        if(i > 0 && i % 10 == 0) {
            restr+= "\n";
        }
    }
    return restr;
}
function swap(arr,index1,index2) {
    var temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}
function selectionSort() {
    var min,temp;
    for(var outer = 0; outer <= this.dataStore.length -2; ++outer) {
        min = outer;
        for(var inner = outer + 1; inner <= this.dataStore.length - 1; ++inner) {
            if(this.dataStore[inner] < this.dataStore[min]) {
                swap(this.dataStore,inner,min); 
            }
        }
    }
}

// 選擇排序測試代碼

var numElements = [9,0,1,8,7,6,2,3,5,4];

var myNums = new CArray(numElements);

myNums.selectionSort();

console.log("------");

console.log(myNums.toString());

代碼分析以下：

假設數組爲：[9,0,1,8,7,6,2,3,5,4]
1. 當min爲0的時候，值爲9，inner爲1，值爲0，因此調換位置，數組變爲[0,9,1,8,7,6,2,3,5,4]
2. 當min爲0的時候都不符合，因此當min爲1的時候，值爲9，inner爲2，值爲1，因此數組變爲[0,1,9,8,7,6,2,3,5,4]
3. 當min爲1的時候，值爲1，內部循環也不符合，因此如今當min爲2的時候，值爲9，inner爲3的時候，值爲8，因此調換位置，數組變爲
[0,1,8,9,7,6,2,3,5,4]
4. 當min爲2的時候，值爲8，inner爲4的時候，值爲7，因此調換位置，數組爲[0,1,7,9,8,6,2,3,5,4].
5. 當min爲2的時候，值爲7，inner爲5的時候，值爲6，因此調換位置，數組爲[0,1,6,9,8,7,2,3,5,4].
6. 當min爲2的時候，值爲6，inner爲6的時候，值爲2，因此調換位置數組爲[0,1,2,9,8,7,6,3,5,4].
7. 當min爲2的時候，值爲2，不符合條件，因此當min爲3的時候，值爲9，因此inner爲4，值爲8，因此調換位置，數組變爲[0,1,2,8,9,7,6,3,5,4]
8. 當min爲3的時候，值爲8，inner爲5的時候值爲7，因此調換位置，數組變爲[0,1,2,7,9,8,6,3,5,4]
9. 當min爲3的時候，值爲7，inner爲6的時候值爲6，因此調換位置數組變爲[0,1,2,6,9,8,7,3,5,4]
10 當min爲3的時候，值爲6，inner爲7的時候值爲3 因此調換位置數組變爲[0,1,2,3,9,8,7,6,5,4]
11 當min爲3的時候值爲3 不符合條件，因此當min爲4的時候，值爲9，inner爲5的時候，值爲8，因此調換位置，數組變爲
[0,1,2,3,8,9,7,6,5,4]
12 當min爲4的時候，值爲8，inner爲6的時候，值爲7，因此調換位置，數組變爲[0,1,2,3,7,9,8,6,5,4].
13 當min爲4的時候，值爲7，inner爲7的時候，值爲6，因此調換位置，數組變爲[0,1,2,3,6,9,8,7,5,4].
14 當min爲4的時候，值爲6，inner爲8的時候，值爲5，因此調換位置，數組變爲[0,1,2,3,5,9,8,7,6,4].
15 當min爲4的時候，值爲5，inner爲9的時候，值爲4，因此調換位置，數組變爲[0,1,2,3,4,9,8,7,6,5].
16 當min爲5的時候，值爲9，inner爲6的時候，值爲8，因此調換位置，數組變爲[0,1,2,3,4,8,9,7,6,5].
17 當min爲5的時候，值爲8，inner爲7的時候，值爲7，因此調換位置，數組變爲[0,1,2,3,4,7,9,8,6,5].
18 當min爲5的時候，值爲7，inner爲8的時候，值爲6，因此調換位置，數組變爲[0,1,2,3,4,6,9,8,7,5].
19 當min爲5的時候，值爲6，inner爲9的時候，值爲5，因此調換位置，數組變爲[0,1,2,3,4,5,9,8,7,6].
20 當min爲6的時候，值爲9，inner爲7的時候，值爲8，因此調換位置，數組變爲[0,1,2,3,4,5,8,9,7,6].
21 當min爲6的時候，值爲8，inner爲8的時候，值爲7，因此調換位置，數組變爲[0,1,2,3,4,5,7,9,8,6].
22 當min爲6的時候，值爲7，inner爲9的時候，值爲6，因此調換位置，數組變爲[0,1,2,3,4,5,6,9,8,7].
23.當min爲7的時候，值爲9，inner爲8的時候，值爲8，因此調換位置，數組變爲[0,1,2,3,4,5,6,8,9,7].
24 當min爲7的時候，值爲8，inner爲9的時候，值爲7，因此調換位置，數組變爲[0,1,2,3,4,5,6,7,9,8].
25 當min爲8的時候，值爲9，inner爲9的時候值爲8，因此調換位置，數組最終變爲[0,1,2,3,4,,5,6,7,8,9]

三：插入排序

原理：插入排序相似於人類按數字或字母順序對數據進行排序。列如：讓班裏的每一個學生上交一張寫有他的名字，學生證號以及我的簡介的索引卡片。學生交上來的卡片是沒有順序的，可是我想讓這些卡片按字母順序排好，這樣就能夠很容易地與班級花名冊進行對照了。

我將卡片帶回辦公室，清理好書桌，而後拿起第一張卡片，卡片上的姓氏是Smith。我把它放到桌子的左上角，而後再拿起第二張卡片。這張卡片上的姓氏是Brown。我把Smith移右，把Brown放到Smith的前面。下一張卡片是Williams，能夠把它放到桌面的最右邊，而不用移動其餘任何卡片，下一張卡片是Acklin。這張卡片必須放在這些卡片的最前面，所以其餘全部卡片必須向右移動一個位置來爲Acklin這張卡片來騰出位置。這就是插入排序的原理；

插入排序有2個循環。外循環將數組元素挨個移動，而內循環則對外循環中選中的元素及它後面的那個元素進行比較。若是外循環中選中的元素比內循環選中的元素小，那麼數組元素會向右移動，爲內循環中的這個元素騰出位置。

插入排序的代碼以下：

// 插入排序
function insertionSort() {
    var temp,inner;
    for(var outer=1; outer <= this.dataStore.length - 1; ++outer) {
        temp = this.dataStore[outer];
        inner = outer;
        while(inner > 0 && (this.dataStore[inner-1] >= temp)) {
            this.dataStore[inner] = this.dataStore[inner -1];
            --inner;
        }
        this.dataStore[inner] = temp;
    }
}

下面是全部的JS代碼以下：

function CArray(numElements) {
    this.dataStore = [];
    this.pos = 0;
    this.numElements = numElements;
    this.insert = insert;
    this.toString = toString;
    this.clear = clear;
    this.swap = swap;
    this.insertionSort = insertionSort;
    for(var i = 0; i < numElements.length; i++) {
        this.dataStore[i] = numElements[i];
    }        
}
        
function clear() {
    for(var i = 0; i < this.dataStore.length; i++) {
        this.dataStore[i] = 0;
    }
}
function insert(element) {
    this.dataStore[this.pos++] = element;
}
function toString() {
    var restr = "";
    for(var i = 0; i < this.dataStore.length; i++) {
        restr += this.dataStore[i] + " ";
        if(i > 0 && i % 10 == 0) {
            restr+= "\n";
        }
    }
    return restr;
}
function swap(arr,index1,index2) {
    var temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}
// 插入排序
function insertionSort() {
    var temp,inner;
    for(var outer=1; outer <= this.dataStore.length - 1; ++outer) {
        temp = this.dataStore[outer];
        inner = outer;
        while(inner > 0 && (this.dataStore[inner-1] >= temp)) {
            this.dataStore[inner] = this.dataStore[inner -1];
            --inner;
        }
        this.dataStore[inner] = temp;
    }
}

// 插入排序的測試代碼

var numElements = [9,0,1,8,7,6,2,3,5,4];

var myNums = new CArray(numElements);

myNums.insertionSort();

console.log("------");

console.log(myNums.toString());

代碼分析以下：

數組爲 [9,0,1,8,7,6,2,3,5,4];

1. outer爲1的時候
temp值爲0，inner等於1，this.dataStore[inner-1]值爲9 >= 0 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[1] = 9,inner自減1 inner爲0
所以this.dataStore[0] = 0;所以數組變爲[0,9,1,8,7,6,2,3,5,4]

2. outer爲2的時候
1. temp = this.dataStore[outer];temp值爲1，inner等於2，this.dataStore[inner-1]值爲9 >=1 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[2] = 9,inner自減1 inner爲1
所以this.dataStore[1] = 1;所以數組變爲[0,1,9,8,7,6,2,3,5,4]

2. inner爲1，temp值爲1，this.dataStore[inner-1]值爲0 >= 1 所以while條件爲false.不成立

3. outer爲3的時候
1. temp = this.dataStore[outer];temp值爲8，inner等於3，this.dataStore[inner-1]值爲9 >=8 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[3] = 9,inner自減1 inner爲2
所以this.dataStore[2] = 8;所以數組變爲[0,1,8,9,7,6,2,3,5,4]
2. inner爲2，temp爲8，this.dataStore[inner-1]值爲1 >= 8 false不成立。同理inner爲1的時候也不成立。

4. outer爲4的時候
1. temp = this.dataStore[outer];temp值爲7，inner等於4，this.dataStore[inner-1]值爲9 >=7 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[4] = 9,inner自減1 inner爲3
所以this.dataStore[3] = 7;所以數組變爲[0,1,8,7,9,6,2,3,5,4]

2. inner爲3的時候，temp爲7，this.dataStore[inner-1]值爲8 >=7 所以while條件爲true，this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[3] = 8,inner自減1 inner爲2
所以this.dataStore[2] = 7;所以數組變爲[0,1,7,8,9,6,2,3,5,4]

3. inner爲2的時候，temp爲7，this.dataStore[inner-1]值爲1 >=7 while條件爲false，不成立，同理inner爲1的時候，也爲false，也不成立。

5. outer爲5的時候：
1. temp = this.dataStore[outer];temp值爲6，inner等於5，this.dataStore[inner-1]值爲9 >=6 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[5] = 9,inner自減1 inner爲4
所以this.dataStore[4] = 6;所以數組變爲[0,1,7,8,6,9,2,3,5,4]

2.inner爲4的時候，temp爲6，this.dataStore[inner-1]值爲8 >=6,所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[4] = 8,inner自減1 inner爲3
所以this.dataStore[3] = 6;所以數組變爲[0,1,7,6,8,9,2,3,5,4]

3.inner爲3的時候，temp爲6，this.dataStore[inner-1]值爲7 >=6,所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[3] = 7,inner自減1 inner爲2
所以this.dataStore[2] = 6;所以數組變爲[0,1,6,7,8,9,2,3,5,4]

4. inner爲2的時候，temp爲6，this.dataStore[inner-1]值爲1 >=6,條件爲false不符合，同理inner=1也不符合。

6. outer爲6的時候
1. temp = this.dataStore[outer];temp值爲2，inner等於6，this.dataStore[inner-1]值爲9 >=2 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[6] = 9,inner自減1 inner爲5
所以this.dataStore[5] = 2;所以數組變爲[0,1,6,7,8,2,9,3,5,4]

2.inner爲5的時候，temp爲2，this.dataStore[inner-1]值爲8 >=2,所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[5] = 8,inner自減1 inner爲4
所以this.dataStore[4] = 2;所以數組變爲[0,1,6,7,2,8,9,3,5,4]

3. inner爲4的時候，temp爲2，this.dataStore[inner-1]值爲7 >=2,所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[4] = 7,inner自減1 inner爲3
所以this.dataStore[3] = 2;所以數組變爲[0,1,6,2,7,8,9,3,5,4]

4. inner爲3的時候，temp爲2，this.dataStore[inner-1]值爲6 >=2,所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[3] = 6,inner自減1 inner爲2
所以this.dataStore[2] = 2;所以數組變爲[0,1,2,6,7,8,9,3,5,4]

5. inner爲2的時候不符合，同理inner=1的時候也不符合。

7. outer爲7的時候
1. temp = this.dataStore[outer];temp值爲3，inner等於7，this.dataStore[inner-1]值爲9 >=3 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[7] = 9,inner自減1 inner爲6
所以this.dataStore[6] = 3;所以數組變爲[0,1,2,6,7,8,3,9,5,4]

2. temp = this.dataStore[outer];temp值爲3，inner等於6，this.dataStore[inner-1]值爲8 >=3 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[6] = 8,inner自減1 inner爲5
所以this.dataStore[5] = 3;所以數組變爲[0,1,2,6,7,3,8,9,5,4]

3. temp = this.dataStore[outer];temp值爲3，inner等於5，this.dataStore[inner-1]值爲7 >=3 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[5] = 7,inner自減1 inner爲4
所以this.dataStore[4] = 3;所以數組變爲[0,1,2,6,3,7,8,9,5,4]

4. temp = this.dataStore[outer];temp值爲3，inner等於4，this.dataStore[inner-1]值爲6 >=3 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[4] = 6,inner自減1 inner爲3
所以this.dataStore[3] = 3;所以數組變爲[0,1,2,3,6,7,8,9,5,4]

5. 當inner爲3的時候 this.dataStore[inner-1]值爲2 >=3 條件爲false，因此不成立，同理inner==2或者1.

8 outer爲8的時候
1. temp = this.dataStore[outer];temp值爲5，inner等於8，this.dataStore[inner-1]值爲9 >=5 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[8] = 9,inner自減1 inner爲7
所以this.dataStore[7] = 5;所以數組變爲[0,1,2,3,6,7,8,5,9,4]

2. temp = this.dataStore[outer];temp值爲5，inner等於7，this.dataStore[inner-1]值爲8 >=5 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[7] = 8,inner自減1 inner爲6
所以this.dataStore[6] = 5;所以數組變爲[0,1,2,3,6,7,5,8,9,4]

3. temp = this.dataStore[outer];temp值爲5，inner等於6，this.dataStore[inner-1]值爲7 >=5 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[6] = 7,inner自減1 inner爲5
所以this.dataStore[5] = 5;所以數組變爲[0,1,2,3,6,5,7,8,9,4]

4. temp = this.dataStore[outer];temp值爲5，inner等於5，this.dataStore[inner-1]值爲6 >=5 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[5] = 6,inner自減1 inner爲4
所以this.dataStore[4] = 5;所以數組變爲[0,1,2,3,5,6,7,8,9,4]

5. 當inner爲4的時候 this.dataStore[inner-1]值爲3 >=5 所以while條件爲false，同理inner=3或者2或者1的時候，都不成立。

9. outer爲9的時候
1. temp = this.dataStore[outer];temp值爲4，inner等於9，this.dataStore[inner-1]值爲9 >=4 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[9] = 9,inner自減1 inner爲8
所以this.dataStore[8] = 4;所以數組變爲[0,1,2,3,5,6,7,8,4,9]

2. temp = this.dataStore[outer];temp值爲4，inner等於8，this.dataStore[inner-1]值爲8 >=4 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[8] = 8,inner自減1 inner爲7
所以this.dataStore[7] = 4;所以數組變爲[0,1,2,3,5,6,7,4,8,9]

3. temp = this.dataStore[outer];temp值爲4，inner等於7，this.dataStore[inner-1]值爲7 >=4 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[7] = 7,inner自減1 inner爲6
所以this.dataStore[6] = 4;所以數組變爲[0,1,2,3,5,6,4,7,8,9]

4. temp = this.dataStore[outer];temp值爲4，inner等於6，this.dataStore[inner-1]值爲6 >=4 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[6] = 6,inner自減1 inner爲5
所以this.dataStore[5] = 4;所以數組變爲[0,1,2,3,5,4,6,7,8,9]

5. temp = this.dataStore[outer];temp值爲4，inner等於5，this.dataStore[inner-1]值爲5 >=4 所以while條件爲true，
this.dataStore[inner] = this.dataStore[inner -1];執行這句代碼後，this.dataStore[5] = 5,inner自減1 inner爲4
所以this.dataStore[4] = 4;所以數組變爲[0,1,2,3,4,5,6,7,8,9]

以上全部的步驟都是插入排序的過程；

四：基本排序算法的計時比較；

下面是全部的JS代碼以下：

function CArray(numElements) {
    this.dataStore = [];
    this.pos = 0;
    this.numElements = numElements;
    this.insert = insert;
    this.toString = toString;
    this.clear = clear;
    this.setData = setData;
    this.swap = swap;
    this.bubbleSort = bubbleSort;
    this.selectionSort = selectionSort;
    this.insertionSort = insertionSort;
          /**
    // 冒泡排序 選擇排序 插入排序
    for(var i = 0; i < numElements.length; i++) {
        this.dataStore[i] = numElements[i];
    }
**/    
// 下面是爲了測試性能的for循環
    for(var i = 0; i< numElements; ++i) {
        this.dataStore[i] = i;
    }    
}
function setData() {
    for(var i = 0; i < this.dataStore.length; i++) {
        this.dataStore[i] = Math.floor(Math.random() * (this.numElements + 1));
    }
}
function clear() {
    for(var i = 0; i < this.dataStore.length; i++) {
        this.dataStore[i] = 0;
    }
}
function insert(element) {
    this.dataStore[this.pos++] = element;
}
function toString() {
    var restr = "";
    for(var i = 0; i < this.dataStore.length; i++) {
        restr += this.dataStore[i] + " ";
        if(i > 0 && i % 10 == 0) {
            restr+= "\n";
        }
    }
    return restr;
}
function swap(arr,index1,index2) {
    var temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}
function bubbleSort() {
    var numElements = this.dataStore.length;
    var temp;
    for(var outer = numElements; outer >= 2; --outer) {
        for(var inner = 0; inner <= outer -1; ++inner) {
            if(this.dataStore[inner] > this.dataStore[inner + 1]) {
                swap(this.dataStore,inner,inner+1);
            }
        }
    }
}
function selectionSort() {
    var min,temp;
    for(var outer = 0; outer <= this.dataStore.length -2; ++outer) {
        min = outer;
        for(var inner = outer + 1; inner <= this.dataStore.length - 1; ++inner) {
            if(this.dataStore[inner] < this.dataStore[min]) {
                swap(this.dataStore,inner,min); 
            }
        }    
    }
}
// 插入排序
function insertionSort() {
    var temp,inner;
    for(var outer=1; outer <= this.dataStore.length - 1; ++outer) {
        temp = this.dataStore[outer];
        inner = outer;
        while(inner > 0 && (this.dataStore[inner-1] >= temp)) {
            this.dataStore[inner] = this.dataStore[inner -1];
            --inner;
        }
        this.dataStore[inner] = temp;
    }
}

如今咱們來分別對上面三種排序先設置10000個隨機元素進行排序後，所花費的多長時間，

1. 冒泡排序測試代碼以下：

var numElements = 10000; var myNums = new CArray(numElements); myNums.setData(); var start = new Date().getTime(); myNums.bubbleSort(); var stop = new Date().getTime(); var t1 = stop - start; console.log("對"+numElements+"個元素執行冒泡排序消耗的時間爲："+t1+"毫秒");

一直刷新會有不一樣的時間在chrome瀏覽器下大概會在700毫秒左右，我就選擇了一次的打印以下：

對10000個元素執行冒泡排序消耗的時間爲：709毫秒

2. 對選擇排序的測試代碼以下：

 var numElements = 10000;

 var myNums = new CArray(numElements);

 myNums.setData();

 var start2 = new Date().getTime();

 myNums.selectionSort();

 var stop2 = new Date().getTime();

 var t2 = stop2 - start2;

 console.log("對"+numElements+"個元素執行選擇排序消耗的時間爲："+t2+"毫秒");

同理和上面同樣操做，最後的時間會在200毫秒左右，我同樣選擇了一次的打印時間以下：

對10000個元素執行選擇排序消耗的時間爲：224毫秒

3. 對插入排序的測試代碼以下：

var numElements = 10000;

var myNums = new CArray(numElements);

myNums.setData();

var start3 = new Date().getTime();

myNums.insertionSort();

var stop3 = new Date().getTime();

var t3 = stop3 - start3;

console.log("對"+numElements+"個元素執行插入排序消耗的時間爲："+t3+"毫秒");

打印會在100毫秒左右，以下所示：

對10000個元素執行插入排序消耗的時間爲：61毫秒

因此這三種基本排序的性能分別爲插入排序 > 選擇排序 > 冒泡排序；

基本排序的理解先到此爲止；下次咱們會來理解下高級排序算法；