數組去重的幾種算法

第一種算法：

算法思想：

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

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

三、將取出的元素與新數組裏面的全部元素進行比較，若是沒有出現，則將該元素添加到新數組中，若是出現，則處理下一個目標數組的元素；

四、目標數組的全部元素均已處理完。

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

View Code

對上面試算法的改進：

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

 1 Array.prototype.deleteRepeat1=function (){
 2         var newArray=[];
 3         // index是目標數組中的每個元素
 4         this.forEach(function(index){
 5             // indexOf方法返回index在newArray中出現的位置，若是沒有出現則返回-1
 6             if(newArray.indexOf(index) == -1){
 7                 newArray.push(index);
 8             }
 9         });
10         return newArray;
11     }

View Code

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

第二種算法：

算法思想：

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

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

 1 Array.prototype.deleteRepeat2=function (){
 2         // 首先對目標數組進行排序
 3         this.sort();
 4         var newArray=[];
 5         // index是目標數組中的每個元素
 6         for(var i=0,len=this.length;i<len;i++){
 7             // 將this[i]與newArray中的最後一個元素比較，由於已經排過序，相同的元素確定在相同的位置了
 8             if(this[i] !== newArray[newArray.length-1]){
 9                 newArray.push(this[i]);
10             }
11         }
12         return newArray;
13     }

View Code

這種算法的優缺點：

去重後的數組是排過序的，並且沒法區分與數字相同的數字字符 好比： 「1」 和 1；

第三種算法：

算法思想：

一、建立一個新數組和新對象；

二、遍歷目標數組中的每個元素，將該元素與對象進行比對，若是不重複則添加到結果數組中，同時將該元素的值做爲對象的屬性，並將該屬性值設爲1；

 1 Array.prototype.deleteRepeat2=function (){
 2         var newArray =[];
 3         // 建立一個空對象
 4         var object = {};
 5         // 每次取出一個元素，與對象進行比對，若是這個元素不重複，則添加到結果數組中，同時把這個元素的內存做爲對象的一個屬性並存入對象中
 6         for(var i=0,len=this.length;i<len;i++){
 7             if(!object[typeof(this[i]) + this[i]]){
 8                 newArray.push(this[i]);
 9                 object[typeof(this[i]) + this[i]]=1;
10             }
11         }
12         return newArray;
13     }

View Code

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

對這個算法的理解：

這裏的對象也能夠換成一個數組，每次將不重複的元素做爲數組的索引，而後將該索引值設爲1，下次再出現時若是array[element]==1;說明此element已經出現過，是重複的。

第四種算法：

算法思想：

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

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

三、處理目標數組的第二個元素，若是這個元素和它前面的元素不一樣，說明是不重複，則添加到結果數組中。

 1 Array.prototype.deleteRepeat3=function (){
 2         var newArray =[this[0]];
 3         this.sort();
 4         for(var i=1;i<this.length;i++){
 5             比較當前元素和前一個元素是否相同，若是重複，排序後，相同的會在一塊兒。
 6             if(this[i] !== this[i-1]){
 7                 newArray.push(this[i]);
 8             }
 9         }
10         return newArray;
11     }

View Code

第五種算法：

算法思想：

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

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

View Code

第六種算法：

算法思想：

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

1 Array.prototype.deleteRepeat3=function (){
2         var newArray=[];
3         newArray=this.filter(function(ele,i,arr) {
4             return arr.indexOf(ele) === i;
5         });
6         return newArray;
7     }

View Code

第七種算法：

這種是利用ES6去重，相對來講更爲簡單

 1 //es6
 2     function deleteRepeat(arr){
 3         const seen=new Map(){
 4             return arr.filter((a)=>!seen.has(a)&&seen.set(a,1));
 5         }
 6     }
 7     //or
 8     function deleteRepeat2(arr){
 9         return Array.form(new Set(arr))
10     }

View Code