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

一：数组去重方法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));