1.冒泡排序

1.1 冒泡排序算法的運作以下：

1.比較相鄰的元素。假如第一個比第二個大，就交流他們兩個。
2.對每一對相鄰元素作一樣的事情，從最先第一對到末端的末了一對。在這一點，末了的元素應當會是最大的數。
3.針對一切的元素反覆以上的步驟，除了末了一個。
4.延續每次對越來越少的元素反覆上面的步驟，直到沒有任何一對数字須要比較。

1.2 javaScript中的完成

    var arr = [9,8,7,6,5,4,3,2,1,0];
    
    //交流arr[i]和arr[j]
    function swap(arr,i,j){
        var temp;
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    //冒泡排序
    function bubbleSort(arr){
        var leap = 0;
        if(arr.length==0)
            return;
        for(var i = 0 ; i < arr.length ; i++){
            leap = 0;
            for(var j = 1 ; j < arr.length ; j++){
                if(arr[j-1] > arr[j]){
                    swap(arr,j-1,j);
                    leap = 1;
                }
            }
            //假如沒有交流，即排序準確，提前完畢
            if(leap == 0){
                return;
            }
        }
        return arr;
    }

    console.log(bubbleSort(arr));  // arr = [0,1,2,3,4,5,6,7,8,9]

冒泡排序總的均勻時候複雜度為Q(n^2)。

2.挑選排序

2.1 挑選排序算法的頭腦：

輪迴arr.length次，從i=0最先，第i次輪迴將比較獲得的最小（或最大）的數與a[i]交流位置，即每次輪迴拿出最值放到其應當在的位置，而且將其踢出下次輪迴。

2.2 javaScript中的完成

//挑選排序
    function selectionSort(arr){
        var min;
        if(arr.length <= 1)
            return;

        for(var i = 0 ; i < arr.length-1 ; i++){
            min=i;
            for(var j = i+1 ; j < arr.length ; j++)
            {       
                if(arr[j] < arr[min]){
                    min = j;
                }
            }

            swap(arr,i,min);

        }
        return arr;
    }

     console.log(selectionSort(arr));  // arr = [0,1,2,3,4,5,6,7,8,9]

比較次數O(n^2），比較次數與關鍵字的初始狀況無關，總的比較次數N=(n-1）+(n-2）+…+1=n*(n-1）/2。交流次數O(n），最好狀況是，已有序，交流0次；最壞狀況交流n-1次，逆序交流n/2次。交流次數比冒泡排序少多了

3.疾速排序

3.1 疾速排序算法的運作以下：

1.找一個數，對數組舉行掃描，小於這個數的放在這個數的左邊，大於它的放在數組右邊
2.在對擺布兩側的數組離別舉行適才的操縱，直到數組長度為1時完畢。

3.2 javaScript中的完成

    //疾速排序
    function fastSort(arr,begin,end){  
        //當end <= begin時完畢遞歸
        if(end <= begin){
            return ;  
        } 

        var t = begin;
        var i = begin+1;
        var j = end;  
        var v = arr[begin]; 

        while (i <= j){  
            //經由過程選定的軸和厥後一個值舉行比較，如后一個值比他小則交流而且兩個同時加一而且再比較，如比他大則a[i]和a[j]舉行交流而且再比較a[begin]和a[i]的值
            if  (arr[i] <= v){  
                swap(arr, t++, i++); 
           
            }else if(arr[i] > v){  
                swap(arr, i, j--);  
            
            }
           
        }
        fastSort(arr, begin, t-1);  
        fastSort(arr, j+1, end);  
    }  
   
    fastSort(arr,0,arr.length-1);
    console.log(arr);  //arr = [0,1,2,3,4,5,6,7,8,9]

此疾速排序是優化過的，可否再優化今後再試試看。

以上代碼有部份是自創的,若有不足請指教^_^