數組去重的幾種算法

第一種算法：

算法思想：

1、構建一個新數組，新數組包含一個元素，元素值為目標數組的一個值；

2、從目標數組的第二個元素開始遍歷，依次取出每一個元素；

3、將取出的元素與新數組里面的所有元素進行比較，如果沒有出現，則將該元素添加到新數組中，如果出現，則處理下一個目標數組的元素；

4、目標數組的所有元素均已處理完。

Array.prototype.deleteRepeat1=function (){
        //構建一個新數組，存放結果,首先給newArray一個初值，初值為調用該函數的數組的第一個值即this[0]
        var newArray=[this[0]];
        //for循環，每次從原數組中取出一個元素
        //用取出的元素循環與結果數組比較
        for(var i=1;i<this.length;i++){
            // 添加一個標記，用於標記當前元素是否在newArray中出現過
            var repeat=false;
            for(var j=0,len=newArray.length;j<len;j++){
                //原數組取出的元素與結果數組元素相同
                if(this[i] == newArray[j]){
                    repeat=true;
                    break;
                }
            }
            //如果原數組中沒有該元素，則存放到結果數組中
            if(!repeat){
                newArray.push(this[i]);
            }
        }
        return newArray;
    }
    var array=[1,1,2,2,2,3,3,4,5,6,6,6,6];
    array.deleteRepeat();//1,2,3,4,5,6

對上面試算法的改進：

利用forEach，indexOf方法替代上述的循環和檢測：

Array.prototype.deleteRepeat1=function (){
        var newArray=[];
        // index是目標數組中的每一個元素
        this.forEach(function(index){
            // indexOf方法返回index在newArray中出現的位置，如果沒有出現則返回-1
            if(newArray.indexOf(index) == -1){
                newArray.push(index);
            }
        });
        return newArray;
    }

但是在IE9+以下並不支持forEach函數；可以重寫forEach 函數實現兼容。

第二種算法：

算法思想：

1、對目標數組進行排序；

2、遍歷目標數組，檢測數組中的第 i 個元素與結果數組中最后一個元素是否相同，如果不同，則將該元素添加到結果數組中；

Array.prototype.deleteRepeat2=function (){
        // 首先對目標數組進行排序
        this.sort();
        var newArray=[];
        // index是目標數組中的每一個元素
        for(var i=0,len=this.length;i<len;i++){
            // 將this[i]與newArray中的最后一個元素比較，因為已經排過序，相同的元素肯定在相同的位置了
            if(this[i] !== newArray[newArray.length-1]){
                newArray.push(this[i]);
            }
        }
        return newArray;
    }

這種算法的優缺點：

去重后的數組是排過序的，而且無法區分與數字相同的數字字符 比如： “1” 和 1；

第三種算法：

算法思想：

1、創建一個新數組和新對象；

2、遍歷目標數組中的每一個元素，將該元素與對象進行比對，如果不重復則添加到結果數組中，同時將該元素的值作為對象的屬性，並將該屬性值設為1；

Array.prototype.deleteRepeat2=function (){
        var newArray =[];
        // 創建一個空對象
        var object = {};
        // 每次取出一個元素，與對象進行比對，如果這個元素不重復，則添加到結果數組中，同時把這個元素的內存作為對象的一個屬性並存入對象中
        for(var i=0,len=this.length;i<len;i++){
            if(!object[typeof(this[i]) + this[i]]){
                newArray.push(this[i]);
                object[typeof(this[i]) + this[i]]=1;
            }
        }
        return newArray;
    }

這種算法的效果最好，速度最快。但是占用內存大。

對這個算法的理解：

這里的對象也可以換成一個數組，每次將不重復的元素作為數組的索引，然后將該索引值設為1，下次再出現時如果array[element]==1;說明此element已經出現過，是重復的。

第四種算法：

算法思想：

1、創建一個新數組保存結果；

2、對目標數組進行排序，將目標數組中的第一個元素存入結果數組中；

3、處理目標數組的第二個元素，如果這個元素和它前面的元素不同，說明是不重復，則添加到結果數組中。

Array.prototype.deleteRepeat3=function (){
        var newArray =[this[0]];
        this.sort();
        for(var i=1;i<this.length;i++){
            比較當前元素和前一個元素是否相同，如果重復，排序后，相同的會在一起。
            if(this[i] !== this[i-1]){
                newArray.push(this[i]);
            }
        }
        return newArray;
    }

第五種算法：

算法思想：

1、利用數組的reduce方法，對數組中的每一個元素進行處理

Array.prototype.deleteRepeat3=function (){
        // 通過數組的reduce方法，對數組中的每一個元素進行處理，原理都一樣，只是使用了不同的方法
        return this.reduce(function(newArray,index){
            if(newArray.indexOf(index)<0){
                newArray.push(index);
            }
            return newArray;
        },[]);
    }

第六種算法：

算法思想：

1、和上面相同，不過是使用了filter方法

Array.prototype.deleteRepeat3=function (){
        var newArray=[];
        newArray=this.filter(function(ele,i,arr) {
            return arr.indexOf(ele) === i;
        });
        return newArray;
    }

第七種算法：

這種是利用ES6去重，相對來說更為簡單

//es6
    function deleteRepeat(arr){
        const seen=new Map(){
            return arr.filter((a)=>!seen.has(a)&&seen.set(a,1));
        }
    }
    //or
    function deleteRepeat2(arr){
        return Array.form(new Set(arr))
    }