JS 之排序算法和去重复算法

排序算法

---

1. 冒泡排序

数组API : arr.sort()

原理：将每个数组元素转为字符串，然后按字符串比较大小。
问题：只能按字符串排序，无法按照数字排序。
解决：自定义比较器函数

//升序排列
function cmp(a,b) {return a-b};
var arr=[4,3,5,6,1];
arr.sort(cmp);
console.log(arr.sort(cmp));//[1,3,4,5,6]
//降序排序
function cmp(a,b) {return b-a};
console.log(arr.sort(cmp));//[6, 5, 4, 3, 1]

2 插入排序
原理：

function insertSort(arr){
    for(var i=0;i<arr.length;i++){
        var t=arr[i];
        var p=i-1;
        while(arr[p]>t&&p>=0){
            arr[p+1]=arr[p];
            p--;
        }
        arr[p+1]=t;
    }
    return arr;
}
var arr=[3,5,2,1,4];
console.log(insertSort(arr));//[1, 2, 3, 4, 5]

3. 快速排序
原理：利用递归算法
缺点：效率较低

var arr=[3,5,1,4,7,6,2];
function quickSort(arr){
    if(arr.length<=1) return arr;
    else{
        var c=parseInt(arr.length/2);
        c=arr.splice(c,1)[0];
        var left=[],right=[];
        for(var i=0;i<arr.length;i++){
            if(arr[i]<c) left.push(arr[i]);
            else right.push(arr[i]);
        }
        return quickSort(left).concat(c,quickSort(right))
    }
}
console.log(quickSort(arr));//[ 1, 2, 3, 4, 5, 6, 7 ]

去重复算法

---

1. 双从遍历
原理：利用遍历，取出每个元素，去新数组中查找，如果找到，就退出循环。判断内层循环收否完整循环完，中间退出，说明找到，什么都不做，完成循环，既没有找到，将值推到新数组中保存。
问题：双层循环，效率极低，不适用于数据量大的情况下

function repeat1(arr){
    var result=[];
    for(var i=0;i<arr.length;i++){
        for(var j=0;j<result.length;j++){
          if(arr[i]==result[j])
            break;
        }
        if(j==result.length)  result.push(arr[i]);
    }
    return result;
}

2. 利用indexOf
原理：严格意义上将，indexOf底层也是遍历，只不过简化了代码量，但对提升效率没有任何帮助

function repeat1(arr){
    var result=[];
    for(var i=0;i<arr.length;i++){
        //for(var j=0;j<result.length;j++){
        //  if(arr[i]==result[j])
        //    break;
        //}
        //if(j==result.length)
        if(result.indexOf(arr[i])==-1)
            result.push(arr[i]);
    }
    return result;
}

3. 利用字符串处理
原理：将数组转化成字符串，利用正则验证中（\w）\1*分组，然后利用API str.replace(kw,function(kw){return kw[0]})替换，然后再将字符串切割成数组
问题：因为排序是遍历、还用到正则，正则使用成本较高，所以此算法效率也低

function repeat3(arr){
    return arr.sort((a,b)=>a-b) //排序
        .join("")  //打散成字符串
        .replace(/(\w)\1*/ig,kw=>kw[0])  //利用正则替换
        .split("");  //切割成数组
}
arr=repeat3(arr);
console.log(String(arr));

4. hash算法
原理：外层遍历数组是必须的，而内层访问hash，如果hash[arr[i]===undefined]说明hash中没有，即结果数组中也没有，将结果保存到结果数组中，效率相对于以上几种方法较高，建议使用

function repeat2(arr){
    var result=[];
    var hash={};
    for(var i=0;i<arr.length;i++){
        if(hash[arr[i]]===undefined){
            hash[arr[i]]=1;
            result.push(arr[i]);
        }
    }
    return result;
}

总结

---

总的来说，在JS排序算法和去重复算中，以上几种，都是较为经典的算法，具体使用哪种，因地制宜，看情况使用