去重和排序

數組去重

方法一：

var arr = [1,1,1,2,2,44,55,3,3];
var newArr = [];
for(var i = 0; i < arr.length; i++){
    var cur = arr[i];
    if (newArr.indexOf(cur) === -1) {
        newArr.push(cur);
    }
}
console.log(newArr);

方法二：

function fixArray(arr) {
    var obj = {};
    for (var i = 0; i < arr.length; i++) {
        var cur = arr[i];
        if (obj[cur] == cur) {
            arr[i] = arr[arr.length - 1];
            arr.pop();
            i--;
            continue
        }
        obj[cur] = cur;
    }
    return arr
}
var arr = [1, 2, 3, 4, 56, 3, 2, 1, 1, 2, 3];
fixArray(arr);

方法三：ES5與ES6，ES7等方法

array.filter(function(item,index,ary){
    return ary.indexOf(item)===index;
})
以上全部的方法都沒法處理NaN的問題，前兩種沒法去重，後一種直接刪掉了NaN
或者
[...new Set([array])]；//能夠處理NaN問題

方法四：能夠去重數組中基本數據類型的值

function noRepeat(arr){
    let ary=[],obj={};
    for(let i=0,len=arr.length;i<len;i++){
        if(!(obj[arr[i]+typeof arr[i]])){
            ary.push(arr[i]);
            obj[arr[i]+typeof arr[i]]=1;
        }
    }
    return ary;
}

其餘方法：字符串去重並記錄重複數目

function unique(string){
let n=0,str='';//n記錄重複的個數，str新的字符串
for(let i=0;i<string.length;i++){
    if(string[i]==str[str.length-1]){
        n++;
    }else{
        if(n>0){
            str+=n+1;
            n=0;
        }
        str+=string[i];
    }
    return str;
    }
}

冒泡排序

當前項和後一項進行比較，若是當前項大於後一項就交換位置

function bubbleSort(arr) {
    var flag = false;
    // 控制比較輪數
    for (var i = 0; i < arr.length - 1; i++) {
        flag = false;
        // 控制比較次數
        for (var j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                arr[j] = arr[j] + arr[j + 1];
                arr[j + 1] = arr[j] - arr[j + 1];
                arr[j] = arr[j] - arr[j + 1];
                flag = true;
            }
        }
        if (!flag) {
            return arr;
        }
    }
};

var arr = [5, 65146, 56, 95, 112, 1, 69, 854, 8, 77, 438];
console.log(bubbleSort(arr));

快速排序

var ary=[98,88,16,4,33,28];

思路：

1. 求出中間值的索引；
2. 經過索引找到中間值；4；
3. 建立兩個數組：left; right;
4. 遍歷數組中的每一項，讓每一項跟4中間值進行比較；比他大的，放右邊，比他小的放左邊；
5. left.concat(16,right)
6. --函數本身調用本身；--遞歸
7. 中止拆分的條件：當數組的長度<=1的時候；直接返回數組

function quickSort(ary) {
    //中止拆分的條件；-若是知足中止拆分，阻斷後續代碼的執行
    if (ary.length <= 1) {
        return ary;//return：1）返回值 2）阻斷程序執行；
    }
    //1.求出中間值的索引；
    var point = Math.floor(ary.length / 2);
    //2.經過索引找到中間值；4；
    var pointValue = ary.splice(point, 1)[0];
    //3.建立兩個數組：left=[]; right=[]
    var left = [];
    var right = [];
    //4.遍歷數組中的每一項，讓每一項跟16中間值進行比較；比他大的，放右邊，比他小的放左邊；
    for (var i = 0; i < ary.length; i++) {
        ary[i] > pointValue ? right.push(ary[i]) : left.push(ary[i]);
    }
    return quickSort(left).concat(pointValue, quickSort(right));
}
var arr = [5, 65146, 56, 95, 112, 1, 69, 854, 8, 77, 438];
console.log(quickSort(arr));

插入排序

var ary=[98,88,16,4,33,28];

思路：

1. 先拎出一個數組； ary.splice(0,1)=>[98]
2. 遍歷ary數組中的每一項；分別跟[4,16,28,88,98]數組進行比較：

插排的核心：拿ary數組中的每一項，跟left數組從後往前的比較，比他小，繼續往前比較，比他大，放到他下一項的前面。

function insertSort(ary) {
    //1.先拎出一個數組；
    var left = ary.splice(0, 1);
    //2.拿ary數組中的每一項，跟left數組從後往前的比較，比他小，繼續往前比較，比他大，放到他下一項的前面；
    for (var i = 0; i < ary.length; i++) {
        var cur = ary[i];
        for (var j = left.length - 1; j >= 0;) {
            if (cur < left[j]) {
                j--;
                //判斷比到頭了
                if (j == -1) {
                    left.unshift(cur);
                }
            } else {
                left.splice(j + 1, 0, cur);
                break;
            }
        }
    }
    return left;
}
var arr = [5, 65146, 56, 95, 112, 1, 69, 854, 8, 77, 438];
console.log(insertSort(arr));