去重和排序

数组去重

方法一：

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));