JavaScript之數組去重

　　前言：昨天看到了別人發的帖子，談到了面試題中經常出現的數組去重的問題。作為一個熱愛學習、喜歡聽老師話的好孩紙，耳邊忽然想起來高中老師的諄諄教導：不要拿到題就先看答案，要先自己思考解答，然后再對照答案檢驗。於是我便開始了獨立思考的過程：

　　首先，我想到的是另建一個結果數組，用來存儲原始數組中不重復的數據。遍歷原始數組依次跟結果數組中的元素進行比較，檢測是否重復。於是乎，我寫出了如下代碼A：

Array.prototype.clearRepetitionA = function(){
    var result = [];
    var isRepetition;
    for(var i=0; i<this.length; i++){
        isRepetition = false;
        for(var j=0; j<result.length; j++){
            if(this[i] === result[j]){
                isRepetition = true;
                break;
            }
        }
        if(!isRepetition){
            result.push(this[i]);
        }
    }
    return result;
} 

 

　　寫完之后，忽然想起來前幾天剛看的ECMAScript 5中的數組方法 indexOf 可以檢索數組元素。於是我又使用 indexOf 方法替代了第二層循環，寫出了如下代碼B：

Array.prototype.clearRepetitionB = function(){
    var result = [];
    for(var i=0; i<this.length; i++){
        if(result.indexOf(this[i]) == -1){
            result.push(this[i]);
        }
    }
    return result;
} 

　　哈，代碼一下子從17行變成了9行了，簡潔多了。高三數學大題解法一般都不止一種的啊，然后我就繼續再想其他方法了。indexOf 方法的意思是搜索整個數組中具有給定值的元素，返回找到的第一個元素的索引，沒有找到就返回 -1 ，第一個參數就是要搜索的值，第二個參數可選：它指定數組中的一個索引，從那里開始搜索，如果省略這個參數，則從頭搜索。思維一發散，想到了前面方法都是檢測值是否重復的，現在有了indexOf 方法不就可以根據檢測到的每個元素的第一次出現時的索引和這個元素自身的索引值比較相等來判斷是否重復嘛。所以，我又寫出了代碼C:

Array.prototype.clearRepetitionC = function(){
    var result = [this[0]];
    for(var i=1; i<this.length; i++){
        if(this.indexOf(this[i]) == i){
            result.push(this[i]);
        }
    }
    return result;
} 

　　寫完這個，又繼續想了想，實在是想不出其他方法了（哎，這三個方法都是很基礎的方法，數據結構、算法沒學好，真心想不出啥驚天地、泣鬼神的牛逼方法來）。於是，我就去對照答案，檢驗自己了。一看答案，發現自己還是真實太弱了，簡單的問題還是有些奇思妙想的。下面不是自己想的了，就不再說太多我的心路歷程了。廢話不多說，直接上經典的答案+解析了。

　　首先，先說一個算法中經常說的以空間換時間的解法，保持隊形，我們就叫它代碼D吧：

Array.prototype.clearRepetitionD = function(){
    var result = [];
    var obj = {};
    var key,type;
    for(var i=0; i<this.length; i++){
        key = this[i];
        type = typeof key;
        if(!obj[key]){
            obj[key] = [type];
            result.push(key);
        }else if(obj[key].indexOf(type)){
            obj[key].push(type);
            result.push(key);
        }
    }
    return result;
} 

　　這個方法中在遍歷原始數組時用一個對象 obj 的屬性來保存原始數組中元素的值。同時這個屬性的值是一個數組，用來存儲這個屬性的類型，這一點可以把原始數組中類似數字1元素和字符串‘1’的元素區分開。這個方法通過額外構建一個對象的方式降低了上面三種方法中indexOf方法所花費的時間，可以說較為高效吧。

　　如果你已經滿足於上面所說的以空間換時間的高效方法而不繼續看下去的話，那就大錯特錯了，好戲總在后頭嘛。現在好戲開場，毫無疑問，就是代碼E了：

Array.prototype.clearRepetitionE = function(){
    var result = [];
    for(var i=0; i<this.length; i++){
        for(var j=i+1; j<this.length; j++){
            if(this[i] === this[j]){
                j = ++i;
            }
        }
        result.push(this[i]);
    }
    return result;
} 

　　代碼D以空間換時間，感覺也就一般般。那么代碼E呢？我擦，這代碼是錯誤的吧，這個真的能去重嗎？是的，起初我都沒看懂這代碼，看了解析后又看了一遍之后才明白過來。那么，沒看懂的看官也要認真的看解析了：第一層從前往后遍歷原始數組，第二層循環是檢測每個元素是否跟它之后的元素重復，如果它之后有重復元素則跳過它；如果這個元素之后所有元素都跟他不重復了，則把它添加到結果數組中。這個方法實現思路就是：獲取無重復的最右一值添加到結果數組中，這個跟第一種方法相比也優化了第二層的循環，效率要比它高，不過這個方法的結果數組中元素的順序跟原始數組中元素的順序不一樣了。

　　看完了代碼E解析的你是不是已經伸出了大拇指、投放出了敬佩的目光呢？（這些鮮花和榮譽別給我，應該給寫這個方法的大神去）。下面再說最后一個方法：那就是先排序，再去重。老規矩，它叫代碼F：

Array.prototype.clearRepetitionF = function(){
    this.sort();
    var result = [this[0]];
    for(var i=1; i<this.length; i++){
        if(this[i] !== result[result.length-1]){
            result.push(this[i]);
        }
    }
    return result;
} 

　　這個先用數組的排序方法sort進行數組元素排序，然后再進行去重工作。這個效率真的會高嗎？哎，沒學好算法什么的，我的答案也就三個字：不知道。如果你知道歡迎評論區告訴我。