JavaScript之数组去重

　　前言：昨天看到了别人发的帖子，谈到了面试题中常常出现的数组去重的问题。做为一个热爱学习、喜欢听老师话的好孩纸，耳边突然想起来高中老师的谆谆教导：不要拿到题就先看答案，要先本身思考解答，而后再对照答案检验。因而我便开始了独立思考的过程：

　　首先，我想到的是另建一个结果数组，用来存储原始数组中不重复的数据。遍历原始数组依次跟结果数组中的元素进行比较，检测是否重复。因而乎，我写出了以下代码A：

 1 Array.prototype.clearRepetitionA = function(){
 2     var result = [];
 3     var isRepetition;
 4     for(var i=0; i<this.length; i++){
 5         isRepetition = false;
 6         for(var j=0; j<result.length; j++){
 7             if(this[i] === result[j]){
 8                 isRepetition = true;
 9                 break;
10             }
11         }
12         if(!isRepetition){
13             result.push(this[i]);
14         }
15     }
16     return result;
17 } 

 

　　写完以后，突然想起来前几天刚看的ECMAScript 5中的数组方法 indexOf 能够检索数组元素。因而我又使用 indexOf 方法替代了第二层循环，写出了以下代码B：

1 Array.prototype.clearRepetitionB = function(){
2     var result = [];
3     for(var i=0; i<this.length; i++){
4         if(result.indexOf(this[i]) == -1){
5             result.push(this[i]);
6         }
7     }
8     return result;
9 } 

　　哈，代码一会儿从17行变成了9行了，简洁多了。高三数学大题解法通常都不止一种的啊，而后我就继续再想其余方法了。indexOf 方法的意思是搜索整个数组中具备给定值的元素，返回找到的第一个元素的索引，没有找到就返回 -1 ，第一个参数就是要搜索的值，第二个参数可选：它指定数组中的一个索引，从那里开始搜索，若是省略这个参数，则从头搜索。思惟一发散，想到了前面方法都是检测值是否重复的，如今有了indexOf 方法不就能够根据检测到的每一个元素的第一次出现时的索引和这个元素自身的索引值比较相等来判断是否重复嘛。因此，我又写出了代码C:

1 Array.prototype.clearRepetitionC = function(){
2     var result = [this[0]];
3     for(var i=1; i<this.length; i++){
4         if(this.indexOf(this[i]) == i){
5             result.push(this[i]);
6         }
7     }
8     return result;
9 } 

　　写完这个，又继续想了想，实在是想不出其余方法了（哎，这三个方法都是很基础的方法，数据结构、算法没学好，真心想不出啥惊天地、泣鬼神的牛逼方法来）。因而，我就去对照答案，检验本身了。一看答案，发现本身仍是真实太弱了，简单的问题仍是有些奇思妙想的。下面不是本身想的了，就再也不说太多个人心路历程了。废话很少说，直接上经典的答案+解析了。

　　首先，先说一个算法中常常说的以空间换时间的解法，保持队形，咱们就叫它代码D吧：

 1 Array.prototype.clearRepetitionD = function(){
 2     var result = [];
 3     var obj = {};
 4     var key,type;
 5     for(var i=0; i<this.length; i++){
 6         key = this[i];
 7         type = typeof key;
 8         if(!obj[key]){
 9             obj[key] = [type];
10             result.push(key);
11         }else if(obj[key].indexOf(type)){
12             obj[key].push(type);
13             result.push(key);
14         }
15     }
16     return result;
17 } 

　　这个方法中在遍历原始数组时用一个对象 obj 的属性来保存原始数组中元素的值。同时这个属性的值是一个数组，用来存储这个属性的类型，这一点能够把原始数组中相似数字1元素和字符串‘1’的元素区分开。这个方法经过额外构建一个对象的方式下降了上面三种方法中indexOf方法所花费的时间，能够说较为高效吧。

　　若是你已经知足于上面所说的以空间换时间的高效方法而不继续看下去的话，那就大错特错了，好戏总在后头嘛。如今好戏开场，毫无疑问，就是代码E了：

 1 Array.prototype.clearRepetitionE = function(){
 2     var result = [];
 3     for(var i=0; i<this.length; i++){
 4         for(var j=i+1; j<this.length; j++){
 5             if(this[i] === this[j]){
 6                 j = ++i;
 7             }
 8         }
 9         result.push(this[i]);
10     }
11     return result;
12 } 

　　代码D以空间换时间，感受也就通常般。那么代码E呢？我擦，这代码是错误的吧，这个真的能去重吗？是的，起初我都没看懂这代码，看了解析后又看了一遍以后才明白过来。那么，没看懂的看官也要认真的看解析了：第一层从前日后遍历原始数组，第二层循环是检测每一个元素是否跟它以后的元素重复，若是它以后有重复元素则跳过它；若是这个元素以后全部元素都跟他不重复了，则把它添加到结果数组中。这个方法实现思路就是：获取无重复的最右一值添加到结果数组中，这个跟第一种方法相比也优化了第二层的循环，效率要比它高，不过这个方法的结果数组中元素的顺序跟原始数组中元素的顺序不同了。

　　看完了代码E解析的你是否是已经伸出了大拇指、投放出了敬佩的目光呢？（这些鲜花和荣誉别给我，应该给写这个方法的大神去）。下面再说最后一个方法：那就是先排序，再去重。老规矩，它叫代码F：

 1 Array.prototype.clearRepetitionF = function(){
 2     this.sort();
 3     var result = [this[0]];
 4     for(var i=1; i<this.length; i++){
 5         if(this[i] !== result[result.length-1]){
 6             result.push(this[i]);
 7         }
 8     }
 9     return result;
10 } 

　　这个先用数组的排序方法sort进行数组元素排序，而后再进行去重工做。这个效率真的会高吗？哎，没学好算法什么的，个人答案也就三个字：不知道。若是你知道欢迎评论区告诉我。