js 數組 去重 算法（轉載）

時間  2019-11-29
標籤 數組 算法 轉載 欄目 JavaScript 简体版
原文   原文鏈接

如下內容可能有重複部分，項目有用上，但還沒來得急整理和驗證。 javascript

 

一：https://www.cnblogs.com/jiayuexuan/p/7527055.htmlphp

1.遍歷數組法html

它是最簡單的數組去重方法（indexOf方法）java

實現思路：新建一個數組，遍歷去要重的數組，當值不在新數組的時候（indexOf爲-1）就加入該新數組中；git

複製代碼 
var arr=[2,8,5,0,5,2,6,7,2];
function unique1(arr){
  var hash=[];
  for (var i = 0; i < arr.length; i++) {
     if(hash.indexOf(arr[i])==-1){
      hash.push(arr[i]);
     }
  }
  return hash;
}
複製代碼

2.數組下標判斷法github

調用indexOf方法，性能和方法1差很少json

實現思路：若是當前數組的第 i 項在當前數組中第一次出現的位置不是 i，那麼表示第 i 項是重複的，忽略掉。不然存入結果數組。數組

複製代碼 
function unique2(arr){
  var hash=[];
  for (var i = 0; i < arr.length; i++) {
     if(arr.indexOf(arr[i])==i){
      hash.push(arr[i]);
     }
  }
  return hash;
}
複製代碼

3.排序後相鄰去除法 瀏覽器

實現思路：給傳入的數組排序，排序後相同的值會相鄰，而後遍歷排序後數組時，新數組只加入不與前一值重複的值。數據結構

複製代碼 
function unique3(arr){
  arr.sort();
  var hash=[arr[0]];
  for (var i = 1; i < arr.length; i++) {
     if(arr[i]!=hash[hash.length-1]){
      hash.push(arr[i]);
     }
  }
  return hash;
}
複製代碼

4.優化遍歷數組法（推薦）

實現思路：雙層循環，外循環表示從0到arr.length，內循環表示從i+1到arr.length

將沒重複的右邊值放入新數組。（檢測到有重複值時終止當前循環同時進入外層循環的下一輪判斷）

複製代碼 
function unique4(arr){
  var hash=[];
  for (var i = 0; i < arr.length; i++) {
    for (var j = i+1; j < arr.length; j++) {
      if(arr[i]===arr[j]){
        ++i;
      }
    }
      hash.push(arr[i]);
  }
  return hash;
}
複製代碼


能夠針對數組中某個屬性名稱去重

function unique4(arr,name){
  var hash=[];
  for (var i = 0; i < arr.length; i++) {
    for (var j = i+1; j < arr.length; j++) {
      if(arr[i][name]===arr[j][name]){
        ++i;
      }
    }
      hash.push(arr[i][name]); //若想保留其它屬性值則不加[name]
  }
  return hash;
}

　　

5.ES6實現

基本思路：ES6提供了新的數據結構Set。它相似於數組，可是成員的值都是惟一的，沒有重複的值。

Set函數能夠接受一個數組（或相似數組的對象）做爲參數，用來初始化。

function unique5(arr){
  var x = new Set(arr);
 return [...x];
}

 擴展：若是重複，則去掉該元素

數組下標去重

複製代碼 
function unique22(arr){
  var hash=[];
  for (var i = 0; i < arr.length; i++) {
     if(arr.indexOf(arr[i])==arr.lastIndexOf(arr[i])){
      hash.push(arr[i]);
     }
  }
  return hash;
}
複製代碼

 

二：https://www.cnblogs.com/wteam-xq/p/4732351.html

 1.遍歷數組法

  最簡單的去重方法， 實現思路：新建一新數組，遍歷傳入數組，值不在新數組就加入該新數組中；注意點：判斷值是否在數組的方法「indexOf」是ECMAScript5 方法，IE8如下不支持，需多寫一些兼容低版本瀏覽器代碼，源碼以下：

複製代碼 
// 最簡單數組去重法
function unique1(array){
  var n = []; //一個新的臨時數組
  //遍歷當前數組
  for(var i = 0; i < array.length; i++){
    //若是當前數組的第i已經保存進了臨時數組，那麼跳過，
    //不然把當前項push到臨時數組裏面
    if (n.indexOf(array[i]) == -1) n.push(array[i]);
  }
  return n;
}
複製代碼
複製代碼 
// 判斷瀏覽器是否支持indexOf ，indexOf 爲ecmaScript5新方法 IE8如下（包括IE8， IE8只支持部分ecma5）不支持
if (!Array.prototype.indexOf){
  // 新增indexOf方法
  Array.prototype.indexOf = function(item){
    var result = -1, a_item = null;
    if (this.length == 0){
      return result;
    }
    for(var i = 0, len = this.length; i < len; i++){
      a_item = this[i];
      if (a_item === item){
        result = i;
        break;
      }  
    }
    return result;
  }
}
複製代碼

 

2.對象鍵值對法

  該方法執行的速度比其餘任何方法都快， 就是佔用的內存大一些；實現思路：新建一js對象以及新數組，遍歷傳入數組時，判斷值是否爲js對象的鍵，不是的話給對象新增該鍵並放入新數組。注意點： 判斷是否爲js對象鍵時，會自動對傳入的鍵執行「toString()」，不一樣的鍵可能會被誤認爲同樣；例如： a[1]、a["1"] 。解決上述問題仍是得調用「indexOf」。

複製代碼 
// 速度最快， 佔空間最多（空間換時間）
function unique2(array){
  var n = {}, r = [], len = array.length, val, type;
    for (var i = 0; i < array.length; i++) {
        val = array[i];
        type = typeof val;
        if (!n[val]) {
            n[val] = [type];
            r.push(val);
        } else if (n[val].indexOf(type) < 0) {
            n[val].push(type);
            r.push(val);
        }
    }
    return r;
}
複製代碼

 

3. 

  仍是得調用「indexOf」性能跟方法1差很少，實現思路：若是當前數組的第i項在當前數組中第一次出現的位置不是i，那麼表示第i項是重複的，忽略掉。不然存入結果數組。

複製代碼 
function unique3(array){
  var n = [array[0]]; //結果數組
  //從第二項開始遍歷
  for(var i = 1; i < array.length; i++) {
    //若是當前數組的第i項在當前數組中第一次出現的位置不是i，
    //那麼表示第i項是重複的，忽略掉。不然存入結果數組
    if (array.indexOf(array[i]) == i) n.push(array[i]);
  }
  return n;
}
複製代碼

 

4. 

  雖然原生數組的"sort"方法排序結果不怎麼靠譜，但在不注重順序的去重裏該缺點毫無影響。實現思路：給傳入數組排序，排序後相同值相鄰，而後遍歷時新數組只加入不與前一值重複的值。

複製代碼 
// 將相同的值相鄰，而後遍歷去除重複值
function unique4(array){
  array.sort(); 
  var re=[array[0]];
  for(var i = 1; i < array.length; i++){
    if( array[i] !== re[re.length-1])
    {
      re.push(array[i]);
    }
  }
  return re;
}
複製代碼

 

5.優化遍歷數組法

  源自外國博文，該方法的實現代碼至關酷炫；實現思路：獲取沒重複的最右一值放入新數組。（檢測到有重複值時終止當前循環同時進入頂層循環的下一輪判斷）

複製代碼 
// 思路：獲取沒重複的最右一值放入新數組
function unique5(array){
  var r = [];
  for(var i = 0, l = array.length; i < l; i++) {
    for(var j = i + 1; j < l; j++)
      if (array[i] === array[j]) j = ++i;
    r.push(array[i]);
  }
  return r;
}
複製代碼

 

demo 源碼

 

三：https://www.jianshu.com/p/79fe3489600f

1.遍歷數組法
最簡單的去重方法，實現思路：新建一新數組，遍歷傳入數組，值不在新數組就加入該新數組中；注意點：判斷值是否在數組的方法「indexOf」是ECMAScript5 方法，IE8如下不支持，需多寫一些兼容低版本瀏覽器代碼，源碼以下：

var arr = [1,3,5,7,9,1,9,5,9,3,5,11,13]; function unique1(array){ var newArr=[];//新建一個新數組 //遍歷參數數組array for(var i=0;i<array.length;i++){ //判斷新數組是否有這個元素值，沒有的話，就把arr[i]給push到新數組newArr中 if(newArr.indexOf(array[i])===-1){ newArr.push(arr[i]); } } return newArr; } console.log(unique1(arr));

效果以下：

 
圖片.png

2.對象鍵值對法
該方法執行的速度比其餘任何方法都快， 就是佔用的內存大一些，實現思路：新建一js對象以及新數組，遍歷傳入數組時，判斷值是否爲js對象的鍵，不是的話給對象新增該鍵並放入新數組。注意 點： 判斷是否爲js對象鍵時，會自動對傳入的鍵執行「toString()」，不一樣的鍵可能會被誤認爲同樣；例如： a[1]、a["1"] 。解決上述問題仍是得調「indexOf」。

var arr = [1,3,5,7,9,1,9,5,9,3,5,11,13]; // 速度最快， 佔空間最多（空間換時間） function unique2(array){ var json={},newArr=[],val,type; for(var i=0;i<array.length;i++){ val=array[i]; //判斷val是什麼數據類型 type=typeof val; console.log("判斷類型"+[type]); //判斷值是否爲js對象的鍵，不是的話給對象新增該鍵並放入新數組 if(!json[val]){ json[val]=[type]; newArr.push(val); } else if(json[val].indexOf(type)<0){ json[val].push(type); newArr.push(val); } } return newArr; } console.log(unique2(arr));

效果以下：

 
圖片.png

3.數組下標判斷法
仍是得調用「indexOf」性能跟方法1差很少，實現思路：若是當前數組的第i項在當前數組中第一次出現的位置不是i，那麼表示第i項是重複的，忽略掉。不然存入結果數組。

var arr = [1,3,5,7,9,1,3,5]; function unique3(array){ var n = [array[0]]; //結果數組 //從第二項開始遍歷 for(var i = 1; i < array.length; i++) { //若是當前數組的第i項在當前數組中第一次出現的位置不是i， //那麼表示第i項是重複的，忽略掉。不然存入結果數組 if (array.indexOf(array[i]) == i) n.push(array[i]); } return n; } console.log(unique3(arr));

效果以下：

 
圖片.png

4.排序後相鄰去除法
雖然原生數組的」sort」方法排序結果不怎麼靠譜，但在不注重順序的去重裏該缺點毫無影響。實現思路：給傳入數組排序，排序後相同值相鄰，而後遍歷時新數組只加入不與前一值重複的值。

var arr = [1,3,5,7,9,1,3,5]; function unique4(array){ array.sort(); var re=[array[0]]; for(var i = 1; i < array.length; i++){ if( array[i] !== re[re.length-1]){ re.push(array[i]); } } return re; } console.log(unique4(arr));
 
圖片.png

5.優化遍歷數組法
該方法的實現代碼至關酷炫，實現思路：獲取沒重複的最右一值放入新數組。（檢測到有重複值時終止當前循環同時進入頂層循環的下一輪判斷）推薦

// 思路：獲取沒重複的最右一值放入新數組 var arr = [1,3,5,7,9,1,3,5]; function unique5(array){ var r = []; for(var i = 0, l = array.length; i < l; i++) { for(var j = i + 1; j < l; j++) if (array[i] === array[j]) j = ++i; r.push(array[i]); } return r; } console.log(unique5(arr));

效果以下：


 
圖片.png

6.經過hash表
思路以下：
hash是一個對象，則存在鍵值對（key：value），只不過如今是爲空的,因此hash[key] = value;
1：i=0;this[i]=this[0]=1; hash[this[0]] = hash[1] , 由於hash初始爲空，沒有找到key=1的值，因此而後undefined，
2：hash[1] = true(此時hash對象就有了第一組鍵值對)，將原數組的第一個數添加到新數組中，重複第一步
3：由於不重複的判斷hash的值都是undefined，而重複的都爲true了,因此不重複都被添加到新數組中
4： 由於hash表存的值是存的地址，放在堆內存中，因此有多少個不重複的元素，就要分多少個內存來存放，因此這種方法比較佔內存，可是相比之下，這種的運算運動是最快的，
5 ：這也就是用空間來換取時間了，數據量比較小，推薦用此方法

var arr = [1,'b','b',4,3,3,4,5,1]; Array.prototype.unique2 = function(){ var hash = {}; //定義一個hash表 var arr1 = []; //定義一個新數組 for(var i=0;i<this.length;i++){ if(! hash[this[i]]){ hash[this[i]] = true; arr1.push(this[i]); } } return arr1; } console.log(arr); console.log(arr.unique2());

效果以下：

 
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程