4-陣列-案例實戰

擴充套件陣列

擴充套件陣列一般通過為Array 物件定義原型方法來實現，這些原型方法能被所有陣列繼承。

Array.prototype.hello=function(){
    console.log("hello!")
}
var a=[1,2,3]
var b=[]
a.hello()
b.hello()
//結果：
//hello！
//hello！

【例】為陣列擴充套件一個求所有元素之和的方法

Array.prototype._sum=Array.prototype.sum||  //檢測是否存在同名方法
(Array.prototype._sum=function(){  //定義該方法
    var _n=0;  //臨時彙總變數
    for(var i in this){  //遍歷當前陣列物件
        if(this[i]=parseFloat(this[i]))  //若陣列元素是數字
            _n+=this[i];  //則進行累加            
    }
    return _n; //返回累加的和
});
Object.prototype.sum=Array.prototype._sum;  //將陣列臨時原型方法賦值給物件的原型方法
var a=[1,2,3,4,5,6,7,8,'9']
console.log(a.sum())
//結果：
//45

上述程式碼陣列第九個元素是一個字串型別的數字，彙總時也被轉換為數值進行累加。

---

陣列去重

var a=[2,3,43,43,554,3,32,4,43,2]
console.log([...new Set(a)])
//結果：
// [ 2, 3, 43, 554, 32, 4 ]

---

插入排序

1.從第一個元素開始，該元素預設為已經被排序
2.取出下一個元素，在已排序的序列中從後向前掃描
3.若已排序的元素大於新元素（temp），將該元素移到下一位置
4.重複步驟3，直到找到已排序的元素小於或等於新元素
5.將新元素插入到該位置後
6.重複步驟2~5

function insertsort(arr){ //從小到大
    for(var i=1;i<arr.length;i++){ 
        var j=i-1;  
        var temp=arr[i];  
        while(j>=0&&temp<=arr[j]){  
            arr[j+1]=arr[j];  
            j--;  
        }            
        arr[j+1]=temp;
    }
    return arr;
}
var a=[1,5,3,5,2,9,7];
console.log(insertsort(a))
//[  1, 2, 3, 5,  5, 7, 9]

---

二分插入排序

二分插入（binary-insert-sort）排序是一種在直接插入排序演算法上進行改動的排序演算法。使用二分查詢的方式，在速度上有一定提升。

1.從第一個元素開始，該元素預設為已經被排序
2.取出下一個元素，在已排序的序列二分查詢到第一個比它大的數的位置
3.將新元素插入到該位置後
4.重複上述兩步

function binaryinsertsort(arr){ //從小到大
    for(var i=1;i<arr.length;i++){
        var left=0,right=i-1;
        var temp=arr[i];
        while(left<=right){
            var middle=parseInt((left+right)/2);
            if(temp<arr[middle]){
                right=middle-1;
            }
            else{
                left=middle+1;
            }
        }
        for(var j=i-1;j>=left;j--){
            arr[j+1]=arr[j];
        }
        arr[left]=temp;
    }
    return arr;
}
var a=[1,5,3,5,2,9,7];
console.log(binaryinsertsort(a))
//[  1, 2, 3, 5,  5, 7, 9]

---

選擇排序

首先在未排序的序列中找到最小（大）元素，存放到排序序列的起始位置，再從剩餘未排序的元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。
n個記錄的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。

function selectsort(arr){ //從小到大   
    for(var i=0;i<arr.length-1;i++){
        var temp=arr[i];
        for(var j=i+1;j<arr.length;j++){
            if(arr[j]<temp) {
                temp=arr[j];
                arr[j]=arr[i];
                arr[i]=temp;
            }            
        }
    }
    return arr;
}
var a=[1,5,3,5,2,9,7];
console.log(selectsort(a))
//[  1, 2, 3, 5,  5, 7, 9]

---

氣泡排序

氣泡排序是一種簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，若它們的順序錯誤就把它們交換過來。

1.比較相鄰的元素。若第一個比第二個大，則交換
2.對每一對相鄰元素作同樣的工作，從開始第一對到結尾最後一對
3.針對所有元素重複以上步驟，除了最後一個
4.重複步驟1~3，直到排序完成

function bubbersort(arr){ //從小到大   
    for(var i=0;i<arr.length-1;i++){
        for(var j=i+1;j<arr.length;j++){
            if(arr[i]>arr[j]){
                var temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
    }
    return arr;
}
var a=[1,5,3,5,2,9,7];
console.log(bubbersort(a))
//[  1, 2, 3, 5,  5, 7, 9]

---

快速排序

快速排序使用分治法來把一個串（list）分為兩個串。

1.從數列中挑出一個元素，稱為“基準”
2.重新排序數列，所有元素比基準值小的擺放在基準值前面，所有元素比基準值大的擺在基準值後面（相同的數可以到任意一邊）。在這個分割槽退出後，該基準就處於數列的中間位置。這個稱為分割槽操作。
3.地櫃地把小於基準值元素的子數列和大於基準值的子數列排序。

function quicksort(arr){ //從小到大   
    if(arr.length<=1){return arr;}
    var left=[];
    var right=[];
    var num=arr[0];
    for(var i=1;i<arr.length;i++){
        if(arr[i]<=num){
            left.push(arr[i]);
        }
        else{
            right.push(arr[i]);
        }
    }
    return quicksort(left).concat([num],quicksort(right));    
}
var a=[1,5,3,5,2,9,7];
console.log(quicksort(a))
//[  1, 2, 3, 5,  5, 7, 9]

---

計數排序

計數排序是一種穩定的演算法。使用一個額外陣列C，其中第i個元素是待排序陣列A中值等於i的元素的個數。然後根據陣列C來將A中的元素排到正確的位置。它只能對整數進行排序。

1.找出待排序陣列中最大和最小的元素
2.統計陣列中每個值為i的元素出現的次數，存入陣列的第i項
3.對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）
4.反向填充目標陣列：將每個元素i放在新陣列的第C（i）項，每放一個元素就將C（i）減去1

function countsort(arr){ //從小到大   
    var max=min=arr[0];
    var B=[],C=[];
    for(var i=0;i<arr.length;i++){
        max=max>=arr[i]?max:arr[i];
        min=min<=arr[i]?min:arr[i];
        C[arr[i]]=C[arr[i]]?C[arr[i]]+1:1;
    }
    for(var j=min;j<max;j++){
        C[j+1]=(C[j+1]||0)+(C[j]||0);
    }
    for(var k=arr.length-1;k>=0;k--){
        B[C[arr[k]]-1]=arr[k];
        C[arr[k]]--;
    }
    return B;    
}
var a=[1,5,3,5,2,9,7];
console.log(countsort(a))
//[  1, 2, 3, 5,  5, 7, 9]