js实现数组去重的三个方法、数组的快速排序

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/u013558749/article/details/51004576

一:数组去重方法1
(思路:新建一个空的result数组,将需要去重的数组中的第一个元素传入,依次与剩余的元素进行对比,不重复则把元素传入到result数组中。)

            Array.prototype.removeDup = function(){
                var result = [this[0]];
                for(var i = 1 ; i<this.length; i++){
                    var repeat = false;

                    for(var j = 0; j<result.length;j++){
                        if(this[i] === result[j]){
                            repeat = true;
                            break;
                        }
                    }
                    if(!repeat){
                        result.push(this[i]);
                    }
                }

                return result;
            }

            var arr = [1,3,1,4,6,6,88];
            console.log(arr.removeDup());

二 : 数组去重方法2
(思路:将数组排序,新建一个空的result数组,将要去重的数组的第一个元素存入,遍历数组,将数组中的各个元素依次与result元素中的最后一个元素进行对比,如果二者不相等则存入result数组中。这种方法主要依据排序后相同的元素是相邻的。)
第二个方法虽然比第一种方法高效,但是因为原数组是是排序的,所在输出的result数组也是排序过后的,如果想要的结果是没有变动原数组元素的位置,这个方法就不可取了。

            Array.prototype.removeDup2 = function(){
                this.sort();
                var result = [this[0]];

                for(var i = 1; i<this.length; i++){
                    if(this[i] !== result[result.length - 1]){
                        result.push(this[i]);
                    }
                }

                return result;
            }

            var arr = [1,3,1,4,6,6,88];
            console.log(arr.removeDup2());

三 : 数组去重方法3(推荐使用)*
(思路:新建一个空的result数组,一个空的对象。遍历需要去重的数组,判断对象中是否存在当前遍历的元素作为属性名,没有的话则将该元素存入result数组中,同时为obj对象添加上该属性名。)

            Array.prototype.removeDup3 = function(){
                var result = [];
                var obj = {};
                for(var i = 0; i < this.length; i++){
                    if(!obj[this[i]]){
                        result.push(this[i]);
                        obj[this[i]] = 1;
                    }
                }

                return result;
            }

            var arr = [1,2,2,5,2,"测试","test","测试","test"];
            console.log(arr.removeDup3());
// 校验一个数组是否有重复项, 与上边是一个原理
function isRepeat(arr){
         let hash = {};
         for(let i in arr) {
             if(hash[arr[i]])
                  return true;
             hash[arr[i]] = true;
         }
         return false;
    }

eg: var data = [0, 1, 2, 1];
    console.log(isRepeat(data)) // true

数组的快速排序
(思路:判断当传入的数组长度大于1的情况下,获取中间值,新建两个空数组,分别用来存放大于中间值和小于中间值的元素,递归调用,最后返回结果。)

            var quickSort = function(arr) {
              if (arr.length <= 1) { return arr; }
              var pivotIndex = Math.floor(arr.length / 2);
              var pivot = arr.splice(pivotIndex, 1)[0];
              var left = [];
              var right = [];
              for (var i = 0; i < arr.length; i++){
                if (arr[i] < pivot) {
                  left.push(arr[i]);
                } else {
                  right.push(arr[i]);
                }
              }
              return quickSort(left).concat([pivot], quickSort(right));
            };

            var arr1 = [1,4,65,21,2,222,111];
            console.log(quickSort(arr1));

额外补充:

递归实现数组去重

            function removeDup(arr,start,end){
                if(start === end){
                    return [arr[start]];
                }else if(start == end-1){ //数组中有两个值
                    if(arr[start] === arr[end]){
                        return [arr[start]];
                    }else{
                        return [arr[start],arr[end]];
                    }
                }

                var ban = Math.floor((end+start)/2);
                var arrLeft = removeDup(arr,start,ban);
                var arrRight = removeDup(arr,ban+1,end);

                var result = arrLeft; //将左边的数组放进去
                for(var i = 0; i < arrRight.length; i++){
                    if(result.indexOf(arrRight[i]) === -1){
                        result.push(arrRight[i]);
                    }
                }
                return result;
            }


            console.log(removeDup(arr1,0,arr1.length-1));

没有更多推荐了,返回首页