一些簡單的數組排序算法

時間 2020-03-24

標籤一些簡單數組排序算法简体版

原文原文鏈接

arraySort 數組排序

這裏爲你們整理了一些簡單的數組排序的算法git

冒泡排序 --- 比較兩個相鄰的元素，替換成正確的位置（你選擇的正序仍是倒序）

快速排序 --- 基線條件 --- 只剩一個元素的時候就是有序的數組

選擇排序 --- 無序中選擇極值，進行排序

插入排序 --- 無序中循環，插入到有序中

冒泡排序

重複地走訪過要排序的元素列，一次比較兩個相鄰的元素，重複地進行直到沒有相鄰元素須要交換，也就是說該元素已經排序完成。這個算法的名字由來是由於越大的元素會經由交換慢慢「浮」到數列的頂端（升序或降序排列），就如同碳酸飲料中二氧化碳的氣泡最終會上浮到頂端同樣，故名「冒泡排序」。github

1. 從數組的第一項 **arr[0]** 項開始，與 **arr[1]** 進行對比，大的日後移動
2. 對每個相鄰的元素，都進行以上操做，直到沒有相鄰元素進行對比,最後一對相鄰  **arr[length-2]-arr[length-1]** 
3. 兩兩對比一輪以後，發現數組最後一個元素是最大的
4. 每走一輪，大的元素都到冒泡到了最後面，因此 ***n個元素，n-1個循環（n-1輪）（n-1個外循環）***（最後第二輪結束的時候，最小的元素已經在最前面了） 
5. 每走一輪，最後的元素已經排好序，因此每走一輪，**比較相鄰元素的次數少了一次  arr.length-1-當前外循環 **

function bubbleSort(arr){
    var length = arr.length;
    for(var i = 0;i<length-1;i++){
        for(var j=0;j<length-i-1;j++){
            var left = arr[j];
            var right = arr[j+1];
            if(left>right){
                arr[j]=right;
                arr[j+1]=left;
            }
        }
    }
    return arr;
}

冒泡排序的優勢：每進行一趟排序，就會少比較一次，由於每進行一趟排序都會找出一個較大值。

每進行一趟比較，每一趟少比較一次，必定程度上減小了算法的量。

快速排序 -遞歸-分而治之

經過一趟排序將要排序的數據分割成獨立的兩部分，而後再按此方法對這兩部分數據分別進行快速排序，每次返回一個有序數組。算法

1. 基數條件（再也不進行遞歸的操做）：數組長度等於1
2. 遞歸條件：數組長度大於1
3. 選擇一個基準值 **base**
4. 大於基準值的放一邊，小於基準值的放一邊 **left right**
5. 分開的每邊 再次挑選基準值，重複3以後的步驟
6. 最後將返回的數組合並在一塊兒

function quickSort(arr){
    if(arr.length<2){
        return arr;
    }
    var base = arr.splice(Math.floor(arr.length/2),1); //基準值
    var left = [];
    var right = [];
    for(var i=0;i<arr.length;i++){
        if(arr[i]<base){
            left.push(arr[i]); //小於基準值
        }else{
            right.push(arr[i]); //大於基準值
        }
    }
    return [].concat(quickSort(left),base,quickSort(right));
}

選擇排序無序中選擇極值進行排序

1. 在數組中選擇出 ** 最小的一項 極值 **（也就是沒有排序的當中）
2. 將其插入到數組的開頭（有序的開頭）
3. 再把選出來的最小一項刪除掉
3. 上面兩部就行成了 （有序的開頭+無序的數組）
4. 每走一輪，前面的有序+1，後面的無序-1，因此，n個元素，***n-1輪*** 第n輪已經找不到無序的了

function selectSort(arr){
    var length = arr.length;
    for(var i = 0;i<length-1;i++){
        var min = arr[i];
        var minIndex = i;
        for(var j = i+1;j<length;j++){ //無序中選擇最極值
            if(arr[j]<min){
                min = arr[j];
                minIndex = j;
            }
        }
        arr.splice(i,0,min); //將極值插入到有序中
        arr.splice(minIndex+1,1);//將原先的位置刪除
    }
    return arr;
}

插入排序無序中循環，插入到有序中

1.假設**arr[0]**爲有序的第一項，arr[0]以後的都爲無序 （有序+無序）
2.從arr[0]以後無序進行循環,插入到**有序**相應的位置中
3.每走一輪，有序+1，無序-1

n.arr[n]和arr[n-1]對比，知足 arr[n-1] > arr[n]， =>=> 在有序中找到相應的位置插入

function insertSort(arr){
    var length = arr.length;
    for(var i = 1;i<length;i++){
        var insert = arr[i]; //插入元素
        var insertIndex = i; // 插入位置
        if(arr[i-1]>arr[i]){ //判斷能不能動，只要前面那一項比他大就能動
            for(var j = i-1;j>=0;j--){
                if(arr[j]>insert){ //前面那一項比他大，那麼將前面那一項的位置記錄下來，
                    insertIndex = j;
                }
            }
            arr.splice(insertIndex,0,insert); //插入到前面去
            arr.splice(i+1,1); //原來位置上的刪除，由於插入了一項，要在原來的位置上加1
        }

    }
    return arr;
}