数组的去重和排序

一：数组的去重方法
1 对象里面，相同的属性，后面的会覆盖前面的
var arr = [1,2,2,3,4,4,6,6,7,7,9];
var b = {};//
var c = [];
for(i = 0; i<arr.length; i++){
b[arr[i]] = arr[i]; //等同于b.a[i] = a[i] 属性是一个变量，所以不能用点语法，要用中括号
}
for(v in b){
c.push(b[v]);//for in 遍历对象，取出value值，然后推到新的空数组里
}
console.log©

 2 indexOf
        var arr = [1,1,1,2,2,2,3,3,4,4,5,5,6,6,7]
        var newarr = [];
        for(i = 0; i<arr.length; i++){
            if(newarr.indexOf(arr[i]) == -1){
                newarr.push(arr[i])
            }
        }
        console.log(newarr)

3 set
var arr = [1,1,1,2,2,2,3,3,4,4,5,5,6,6,7]
var arr2 = new Set(arr);
var arr3 = new Array(…arr2)
var arr4 = Array.from(…arr2)

4 遍历数组,如果数组的第i项在数组中第一次出现的位置不是i
var arr = [1,2,2,2,3,3,5,5,5,6,6,6,6];
function fn(arr){
var e = [];
for(i = 0; i<arr.length; i++){
if(arr.indexOf(arr[i]) == i){//遍历数组,如果数组的第i项在数组中第一次出现的位置不是i
//则表示第i项是重复的,否则不重复,存入数组e
e.push(arr[i])
}
}
return e;
}
console.log(fn(arr))

        //6
        var arr = [1,2,2,2,3,3,5,5,5,6,11,12,12,22,22,6,6,6];
        function fn1(arr){
            arr.sort()
            var e = [1,2,3];                
            for(i = 0; i<arr.length; i++){
                if(arr[i] != e[e.length - 1]){
                    e.push(arr[i])
                }
            }
            return e;
        }
        
        console.log(fn1(arr))
        
        //7
        var arr = [1,2,2,3,1,3,5,5,5,6,11,12,12,22,22,6,6,6];
        function fn2(arr){
            var r = [];
            for(i = 0; i<arr.length; i++){
                for(j = i+1; j<arr.length; j++){
                    if(arr[i] == arr[j]){
                        j = ++i;    
                        //console.log(j)
                    }                       
                }
                r.push(arr[i]);                 
            }
            return r
        }
        console.log(fn2(arr))

二：数组的排序方法
1.冒泡排序
for (let i = 0; i < arr.length - 1; i++) { //此处表示比较躺数
for (let j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
let temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
时间复杂度
最好的情况：数组本身是顺序的，外层循环遍历一次就完成O(n)
最坏的情况：，O(n2)数组本身是逆序的，内外层遍历O(n2)
空间复杂度
开辟一个空间交换顺序O(1)
稳定性
稳定，因为if判断不成立，就不会交换顺序，不会交换相同元素
冒泡排序它在所有排序算法中最简单。然而， 从运行时间的角度来看，冒泡排序是最差的一个，它的复杂度是O(n2)。
冒泡排序比较任何两个相邻的项，如果第一个比第二个大，则交换它们。元素项向上移动至正确的顺序，就好像气泡升至表面一样，冒泡排序因此得名。
交换时，我们用一个中间值来存储某一交换项的值。其他排序法也会用到这个方法，因此我 们声明一个方法放置这段交换代码以便重用。
2.选择排序
for (let i = 0; i < arr.length - 1; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
let temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
}

3.快速排序
var quickSort = function(arr) {
if(arr.length < 1) {//如果数组就是一项，那么可以直接返回
return arr;
}
var centerIndex = Math.floor(arr.length / 2);//获取数组中间的索引
var centerValue = arr[centerIndex];//获取数组中间项
var left = [], right = [];
for(var i = 0; i < arr.lenght; i++){
if(arr[i] < centerValue){
left.push(arr[i]);
}else{
right.push(arr[i]);
}
}
return quickSort(left).contanct([centerValue], quickSort(right));//递归调用
}