数组去重和数组排序

数组去重

1. 把数组 每一项和后面的项比较：如果相等，证明后面的项是重复的，我们把后面的重复项删掉即可(改变原有数组方法)

 // 数组去重
 1:  那每一项和后边的项 比较 ；如果相等 ，证明后边的项时重复的； 我们把 后边的重复项 删除即可
    function removeRep(ary) {
        for(var i = 0; i < ary.length; i++){
            var cur = ary[i];//当前项
            for(var n = i+1; n < ary.length; n++){
                //我们要用当前项
                
                
                 和后边的 每一项作比较；如果相等 就把后边相等的这一项 删掉
                if(cur == ary[n]){
                    ary.splice(n,1);
                    // 当我们删除数组的某一项时， 会导致 后边的项 统一向前错一位（数组的塌陷问题），这时我们若还想拿到数组的每一项 ，需要讲我们变化的索引 - 1；
                    n--;
                }
            }
        }
        return ary;
    }
    var ary2=[1,1,2,3,1,4,5,5,4,3,4,4,4,44,2,33,34,33];
    console.log(removeRep(ary2))

2. 把数组 每一项和后面的项比较：如果相等，证明后面的项是重复的，我们把后面的重复添加到新数组中（不改变原有数组）

Array.prototype.removeRep1= function(){
 var arr = this,
  result = [],
  i,
  j,
  len = arr.length;
 for(i = 0; i < len; i++){
  for(j = i + 1; j < len; j++){
   if(arr[i] === arr[j]){
    j = ++i;
   }
  }
  result.push(arr[i]);
 }
 return result;
}
var arra = [1,2,3,4,4,1,1,2,1,1,1];
arra.removeRep1();  
 

3. 利用对象属性名不能重复的特性,循环数组 把数组的每一项 当作某个对象的属性名 存储到 这个对象中,利用对象的属性名不能重复；结果会有排序，这是因为默认行为会给数字属性名 排序；

function removeRep2(ary) {
        var obj = {},arr = [];
        for(var i = 0; i < ary.length; i++){
            obj[ary[i]] = ary[i];
        }
        console.log(obj);
        for(var k in obj){
            arr.push(obj[k])
        }
        return arr;
    }
    var ary3 = [1,1,2,4,2,1,6,2,1,3,4];
    console.log(removeRep2(ary3));

4.先将原数组排序，在与相邻的进行比较，如果不同则存入新数组

function removeRep3(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;

}

5.新建一新数组，遍历传入数组，值不在新数组就push进该新数组中(* IE8以下不支持数组的indexOf方法)

function  removeRep4(array){
    var temp = []; //一个新的临时数组
    for(var i = 0; i < array.length; i++){
        if(temp.indexOf(array[i]) == -1){
            temp.push(array[i]);
        }
    }
    return temp;
}

var aa = [1,2,2,4,9,6,7,5,2,3,5,6,5];
console.log( removeRep4(aa));

6.利用数组中的filter方法(本方法转载他人)

var arr = ['apple','strawberry','banana','pear','apple','orange','orange','strawberry'];
3  var r = arr.filter(function(element,index,self){
4     return self.indexOf(element) === index;
5  });
6  console.log(r);

数组排序

一.reverse函数（数组反转，倒序）sort函数（十以内排序）

1..reverse 函数（数组反转，倒序）

var ary = [1,2,3,4,5];
var res = ary.reverse();返回一个倒叙后的数组，跟原数组是同一个地址，
自己写的倒序方法
①function myReverse(ary) {
        for(var i = 0; i < ary.length/2 ; i++){
            var temp = ary[i];
            ary[i] = ary[ary.length -1 - i];
            ary[ary.length -1 - i] = temp;
        }
        return ary;
    }
②function myReverse2(ary) {
        var arr = [];
        // for(var i = 0; i < ary.length ; i++){
        //     arr.unshift(ary[i])
        // }
        for(var i = ary.length-1; i >= 0; i--){
            arr.push(ary[i])
        }
        // ary = arr;
        return arr;
    }

* 2、数组的排序
* sort
* 参数可以没有 没有参数时， 它是只能实现 10 以内的排序
* 有参数时，参数是个函数（回调函数）
* 返回值 是排好序的 数组 跟 原数组是一个地址
*
* */

var ary2 = [1,2,4,2,1,5,3,7,5,9,6];
var res2 = ary2.sort();
res2[0] = 10;
console.log(res2, ary2);
// 有回调函数时

var ary3 = [2342,11,32,12,232,245];
console.log(ary3);
ary3.sort(function(a,b){
    console.log(a, b);
    // 当返回值时 正数时  对应的两项要调换位置
    return a - b;
});

ary3.sort(function(a,b){
    console.log(a, b);
    // 当返回值时 正数时  对应的两项要调换位置
    return b - a;
});
console.log(ary3);

方法一： 数组冒泡排序

 var ary =[2,4,5,1,6,34,15,87,8,98,567,555,45,]
    //俩项俩项的比较，如果后一项比前一项大，则不交换顺序，否则俩者交换顺序；
  function mysort(ary){
  for (var i = 0; i < ary.length-1; i++) {
        for (var n= 0; n< ary.length-1-i; n++) {
            var temp =ary[n];
            if(ary[n+1]<ary[n]){
                ary[n]=ary[n+1];
                ary[n+1]=temp;
            }
        }
    }
    return ary ;
  }
 mysort(ary);

方法二. 先去找数组中间一项，把这一项拿出来：用拿出来之后的数组中的每一项跟 拿出来这一项比较；比这项大的放到一个数组，比这一项小的放到另一个数组中；

function quickSort(ary) {
        if (ary.length <= 1) {
            return ary
        };
        var n = parseInt(ary.length / 2);
        var cur = ary.splice(n, 1)[0];
        var left = [], right = [];
        for (var i = 0; i < ary.length; i++) {
            if (ary[i] < cur) {
                left.push(ary[i])
            } else {
                right.push(ary[i])
            }

        }return  quickSort(left).concat(cur,quickSort(right));
    }
    var ary1=[5,3,6,9,2,4,8];
    var temp =quickSort(ary1);
    var temp =quickSort([]).concat(2,quickSort([5,3,7,8,4,2]))