数组去重的几种方法

数组去重,这个知识点很重要,很多面试的地方都会问这个这个问题,我总结了一下

  1. 第一种方法 ,最基本的去重方法,

  • 思路: 定义一个新数组,并存放原数组中的第一个元素,然后将旧数组的元素一一与新数组的元素进行对比,如果不相同就放到新数组中

  • 代码实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    var arr = [1, 2, 5, 8, 9, 6, 3, 4, 0, 4, 7, 5, 2, 0, 3];

            function unique(arr) {
                //定义一个新数组,新数组里面只有一个数,这个数是旧数组的第一个值
                var res = [arr[0]];
                // console.log(res);  // 这不放心可以打印一下
                // 
                for (var i = 0; i < arr.length; i++) {
                    var repeat = false;
                    for (var j = 0; j < res.length; j++) {
                        if (arr[i] == res[j]) {
                            repeat = true;
                            break;
                        }
                    }
                    if (!repeat) {
                        res.push(arr[i]);
                    }
                }
                return res;
            }
          console.log(unique(arr));   //(10) [1, 2, 5, 8, 9, 6, 3, 4, 0, 7]

    每一步进行解释:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    function unique(arr) {
               //定义一个新数组,新数组里面只有一个数,这个数是旧数组的第一个值
               var res = [arr[0]];
               // console.log(res);  // 这不放心可以打印一下
               // 遍历旧数组
               for (var i = 0; i < arr.length; i++) {
                   // 这里定义一个变量为false
                   var repeat = false;
                   // 接着遍历 新数组
                   for (var j = 0; j < res.length; j++) {
                       // 这里进行判断,如果变量到的这个旧数组中的这个数和新数组的这个数相等,将开关定义为true  并破坏循环,下面的将不执行,也就是内层循环不执行
                       if (arr[i] == res[j]) {
                           repeat = true;
                           break;
                       }
                   }
                   // 上面的代码执行完之后如果 repeat 为true的话,说明相等,如果不想等的话,这个repeat就是false 取反就是 true ,将循环到的旧数组中的这个数推送到,新数组中,然后,在此循环
                   if (!repeat) {
                       res.push(arr[i]);
                   }
               }
               return res;
           }
           console.log(unique(arr));
  1. 先排序在进行去重
  • 思路: 先将原数组进行排序,在与相邻的进行比较, 如果不同,就放到新数组中
  • 代码实现 : 
1
2
3
4
5
6
7
8
9
10
11
12
13
var arr = [1, 2, 5, 8, 9, 6, 3, 4, 0, 4, 7, 5, 2, 0, 3];

    function unique(arr) {
        var arr2 = arr.sort();
        var res = [arr2[0]];
        for (var i = 1; i < arr2.length; i++) {
            if (arr2[i] != res[res.length - 1]) {
                res.push(arr2[i]);
            }
        }
        return res;
    };
    console.log(unique(arr));

每一步进行解释: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var arr = [1, 2, 5, 8, 9, 6, 3, 4, 0, 4, 7, 5, 2, 0, 3];

        function unique(arr) {
            // 将旧数组进行升序排序
            var arr2 = arr.sort();
   			//console.log(arr2); --> [0, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9]
            // 新数组中存放旧数组中的第一个值
            var res = [arr2[0]];
            // 变量旧数组,从第二个数进行开始,
            for (var i = 1; i < arr2.length; i++) {
                // 因为是进行排序过得数组,进行判断,如果旧数组中循环到的值不等于旧数组中的最后一个,就将这个数推送到新数组中
                if (arr2[i] != res[res.length - 1]) {
                    res.push(arr2[i]);
                }
            }
            return res;
        };
        console.log(unique(arr));  --> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  1. 利用对象的属性进行去重 :
  • 思路:每次取出原数组中的元素,然后在对象中访问这个元素,,如果在说明重复
  • 代码实现 : 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
var arr = [1, 2, 5, 8, 9, 6, 3, 4, 0, 4, 7, 5, 2, 0, 3];

function unique(arr) {
            var res = [];
            var obj = {};
            for (var i = 0; i < arr.length; i++) {
                if (!obj[arr[i]]) {
                    res.push(arr[i]);
                    obj[arr[i]] = 1;
                }
            }
            return res;
        }
        console.log(unique(arr));

每一步进行解释: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var arr = [1, 2, 5, 8, 9, 6, 3, 4, 0, 4, 7, 5, 2, 0, 3];

function unique(arr) {
            var res = [];
            var obj = {};
            for (var i = 0; i < arr.length; i++) {
            // 如果这个对象中有这个属性,取反就是false,里面代码不执行,如果没有,取反为true,执行里面的代码,将旧数组中的这个数,推送到新数组中,
                if (!obj[arr[i]]) {
                    res.push(arr[i]);
                    obj[arr[i]] = 1;
                }
            }
            return res;
        }
        console.log(unique(arr));
  1. 利用下标进行查询 : 
1
2
3
4
5
6
7
8
9
10
function unique(arr) {
    var newArr = [];
    for(var i = 0 ;i < arr.length ;i++){
        if(newArr.indexof(arr[i]) == -1){
            newArr.push(arr[i]);
        }
    }
    return newArr;
}
console.log(unique(arr));

进过实验,上面代码没有什么问题,如果有问题,请指出!!

本文标题:数组去重的几种方法

文章作者:李大玄

发布时间:2018-07-21, 12:58:18

最后更新:2018-07-21, 13:50:19

原始链接:http://yoursite.com/2018/07/21/数组去重的几种方法/

许可协议: "署名-非商用-相同方式共享 4.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 数组去重,这个知识点很重要,很多面试的地方都会问这个这个问题,我总结了一下
|