javascript 常用算法总结

　　算法是程序的灵魂。虽然在前端的开发环境中排序算法不是很经常用到，但常见的排序算法还是应该要掌握的。我在这里从网上整理了一下常见排序算法的javascript实现，方便以后查阅。

一、归并排序：

function merge(left, right){
     var result  = [],
         il      = 0,
         ir      = 0;
 
     while (il < left.length && ir < right.length){
         if (left[il] < right[ir]){
             result.push(left[il++]);
         } else {
             result.push(right[ir++]);
         }
     }
 
     return result.concat(left.slice(il)).concat(right.slice(ir));
 }

function mergeSort(items){ 
     // 结束条件: 数组元素少于2个
     if (items.length < 2) {
         return items;
     }
 
     var middle = Math.floor(items.length / 2),
         left   = items.slice(0, middle),
         right  = items.slice(middle);
 
     return merge(mergeSort(left), mergeSort(right));
 }

function mergeSort2(items){ 
     if (items.length < 2) {
         return items;
     }
 
     var middle = Math.floor(items.length / 2),
         left   = items.slice(0, middle),
         right  = items.slice(middle),
         params = merge(mergeSort(left), mergeSort(right));
     
     params.unshift(0, items.length);
     items.splice.apply(items, params);
     return items;
 }

二、插入排序：

function insertionSort(items) {
    var len = items.length,    
        value,                    
        i,                        
        j;                         
    
    for (i=0; i < len; i++) {
        value = items[i];
        for (j=i-1; j > -1 && items[j] > value; j--) {
            items[j+1] = items[j];
        }
        items[j+1] = value;
    }
    return items;
}

三、选择排序：

function swap(items, firstIndex, secondIndex){
     var temp = items[firstIndex];
     items[firstIndex] = items[secondIndex];
     items[secondIndex] = temp;
}

function selectionSort(items){ 
     var len = items.length,
         min;
 
     for (i=0; i < len; i++){
         min = i;
         for (j=i+1; j < len; j++){
             if (items[j] < items[min]){
                 min = j;
             }
         }
 
         if (i != min){
             swap(items, i, min);
         }
     }
 
     return items;
 }

四、冒泡排序：

function swap(items, firstIndex, secondIndex){
    var temp = items[firstIndex];
     items[firstIndex] = items[secondIndex];
     items[secondIndex] = temp;
}

function bubbleSort(items){ 
     var len = items.length,
         i, j, stop;
 
     for (i=0; i < len; i++){
         for (j=0, stop=len-i; j < stop; j++){
             if (items[j] > items[j+1]){
                 swap(items, j, j+1);
             }
         }
     }
 
     return items;
 }

五、快速排序：

例：arr = [30, 19, 7, 59, 2, 16, 4]; 找出数组中间点为59，循环数组，如果小于59存储到left中，否则存储到right中，然后

var quickSort = function(arr) {
　　if (arr.length <= 1) { return arr; }
　　var pivotIndex = Math.floor(arr.length / 2);
　　var pivot = arr.splice(pivotIndex, 1)[0];
　　var left = [];
　　var right = [];
　　for (var i = 0; i < arr.length; i++){
　　　　if (arr[i] < pivot) {
　　　　　　left.push(arr[i]);
　　　　} else {
　　　　　　right.push(arr[i]);
　　　　}
　　}
　　return quickSort(left).concat([pivot], quickSort(right));
};

六、二分法查找：

function binarySearch(items, value){ 
     var startIndex  = 0,
         stopIndex   = items.length - 1,
         middle      = Math.floor((stopIndex + startIndex)/2);
 
     while(items[middle] != value && startIndex < stopIndex){
 
         if (value < items[middle]){
             stopIndex = middle - 1;
         } else if (value > items[middle]){
             startIndex = middle + 1;
         }
 
         middle = Math.floor((stopIndex + startIndex)/2);
     }
 
     return (items[middle] != value) ? -1 : middle;
 }

七、基数排序：

var countSort = function(array) {
   var i, z = 0, count = [],
   min = Math.min.apply({}, array),
   max = Math.max.apply({}, array),
   size = array.length;
   //给新数组预填为零
   for (i = min; i <= max; i++) {
     count[i] = 0;
   }
   for (i=0; i < size; i++) {
     count[array[i]]++;
   }
  
   for (i = min; i <= max; i++) {
     while (count[i]-- > 0) {//循环新数组，如果不为零，则把i返回array
       array[z++] = i;
     }
   }
   return array;
 }

八、希尔排序：

function shellSort(array) {
    var j, i, v, h=1, s=3, k,n = array.length;
    var result = "";
    var count = 0;
    while(h < n)
        h=s*h+1;
   
    while(h > 1) {
        h=(h-1)/s;
          for (k=0; k<h; k++)
            for (i=k+h,j=i; i<n; i+=h, j=i) {
                  v=array[i];
                while(true)
                    if ((j-=h) >= 0 && array[j] > v)
                        array[j+h]=array[j];
                    else
                        break;
                array[j+h]=v;
                
            }
            count++;
            result += "<br />第" + count + "遍排序的结果是:";
            for (var n = 0; n < array.length; n++) {
                  result += array[n] + ",";
             }
    }
    return result;
}

九、组合排序：

var combSort = function(array){
    var gap = array.length;
    do{
        gap = gap * 10 / 13
        if(gap === 9 || gap === 10)
            gap = 11
        if(gap < 1){
            gap = 1
        }
        var swapped = false;
        for(var i=0;i<array.length-gap;i++){
            var j = i + gap
            if(array[i]>array[j]){
                var temp = array[i];
                array[i] = array[j];
                array[j] = temp;
                test(array)
                swapped = true
            }
        }
        if(gap == 1 && !swapped){
            break;
        }
    }while(1);
}

十、鸡尾酒排序：

var cocktailSort= function(array) {
    var top = array.length - 1, bottom = 0,flag = true,i, j;
    while (flag) {
        flag = false;
        //从左到右到大，把最大的放到每次范围的最右边
        for (i = bottom; i < top; i++) {
            if (array[i] > array[i + 1]) {
                swap(array, i, i + 1);
                flag = true;
            }
        }
        top--;
        //从右到到左，把最小的放到每次范围的最小边
        for (j = top; j > bottom; j--) {
            if (array[j] < array[j - 1]) {
                swap(array, j, j - 1);
                flag = true;
            }
        }
        bottom++;
    }
}

var swap = function(array,a,b){
    var tmp = array[a];
    array[a] = array[b]
    array[b] = tmp;
}

二、js数组 sort方法的分析

　　javascript 中 Array.sort()方法是用来对数组项进行排序的 ，默认情况下是进行升序排列，实例代码如下：

    var arrA = [6,2,4,3,5,1];
    arrA.sort();
    document.writeln(arrA);
　 //结果是：1,2,3,4,5,6 

      sort() 方法可以接受一个 方法为参数 ，这个方法有两个参数。分别代表每次排序比较时的两个数组项。sort()排序时每次比较两个数组项都回执行这个参数，并把两个比较的数组项作为参数传递给这个函数。当函数返回值为1的时候就交换两个数组项的顺序，否则就不交换。

实例如下：

    var arrA = [6,2,4,3,5,1];
    /*arrA.sort();
    document.writeln(arrA);
    */

    function desc(x,y)
    {
        if (x > y)  
            return -1;
        if (x < y)          
            return 1;
    }
    function asc(x,y)
    {
        if (x > y)  
            return 1;
        if (x < y)          
            return -1;
    }

    arrA.sort(desc);    // sort by desc
    document.writeln(arrA);
    document.writeln("<br>");
    arrA.sort(asc);    //sort by asc
    document.writeln(arrA);

　　//输出结果：

　　6,5,4,3,2,1 
　　1,2,3,4,5,6 

 

另外，可以直接把一个无名函数直接放到sort()方法的调用中。如下的例子是将奇数排在前面，偶数排在后面，例子如下：

var arrA = [6,2,4,3,5,1];
arrA.sort( function(x, y) {
            if (x % 2 ==0)
                return 11;
            if (x % 2 !=0)
                return -1;
        }
);
document.writeln(arrA);

//输出：1,5,3,4,6,2 

二、排列组合

从1-10的数中取出六个数字，能排列出多少组不同的顺序

C10 6公式：(1*2*3*4*5*6*7*8*9*10)/((1*2*3*4)*(1*2*3*4*5*6))

<script>
    function arrangement(total, target){　　　　// @total：总的排列数　　@target：组合的总数
        var nTotal = 1;
        var nTarget = 1;
        var nNum = 1;
        
        for(var i=1; i<=total; i++){
            nTotal *= i;
        }
        
        for(var k=1, tar=total-target; k<=tar; k++){
            console.log(tar);
            nTarget *= k;
        }
        
        for(var s=1; s<=target; s++){
            nNum *= s;    
        }
        
        console.log(nTotal,nTarget,nNum)
        
        return nTotal/(nTarget*nNum);
    }
    
    var result = arrangement(16, 6);
    console.log(result);
</script>

三、冒泡排序

原理：

　　较相邻的元素。如果第一个比第二个大，就交换他们两个。

　　用两个循环分别取出第一个数和第二个数，然后做比较如果小于或者大于就将通过一个变量将两个位置互换，并跳出循环，进行下一个数的比较

<script>
    var arr = [2,434,7,9,200,11,23,46,238,45,0,67,3,32,12,32,444,555,666,775,443];
    var len = arr.length;
    var nMax = 0;
    
    function bubbleSort(array){
　　　　　　var i = 0, len = array.length, j, d; 
        for(i; i<len; i++){
            for(j=0; j<len; j++){
                if(array[i] < array[j]){　　　　// 冒泡从高到低
                    d = array[j]; 
                    array[j] = array[i]; 
                    array[i] = d;    
                    break;
                }        
            }
        }
 　　　　　　return array;        
    }

    var getSort = bubbleSort(arr);
    document.write(getSort);
</script>

四、计算百分比

　　胜200   平10      负40  　　各占的百分比

　　公式：数量 / 总数 * 100

　　　　　求200占的百分比就是 200/250*100=80%

// 保留两位小数
// @num：数量   @sum：总数
function ratio(num, sum){
    if(!num || !sum){
        return ;
    }
    var nVal = num / sum * 100;
    return nVal.toFixed(2);
}

 

五、一组数中有多少个重复的数，并重复了多少次

<script>
    var arr=[1, 3, 1, 3, 3, 2, 5, 6, 7, 5, 4, 3];
    var json={};

    for(var i=0; i<arr.length; i++){
        var ret = arr[i];
        if(!json[ret]){
            json[ret]=1;
        }
        else {
            json[ret]++;
        }
    };

    for(var i in json){
        alert('"'+i+'"出现了:'+json[i]+'次')
    };
</script>

六、表格排序

<script>
/*
* 思路：
* 1、先获取所有tr的指针（DOM元素）
* 2、通过sort进行排序
* 3、排序后的指针重新
* */

    function sortTabel(){
        var oTab = $("#tab tbody");
        var oArr = [];
        oTab.find("tr").each(function(){
            oArr.push($(this));
        })

        // console.log(oArr);
        oArr.sort(generateCompareTRs("des"));

        console.log(oArr);
        $.each(oArr, function(i){
            oTab.append(oArr[i]);
        })
    }

    function generateCompareTRs(type){
        return function compareTRs(t1,t2){
            var v1 = parseInt(t1.find("td:eq(0)").text());      // 获取比较列的号
            var v2 = parseInt(t2.find("td:eq(0)").text());

            if(type==="des"){   // 降序
                if(v1>v2){
                    return 1;
                }
                else{
                    return -1;
                }
            }
            if(type==="asc"){   // 升序
                if(v1>v2){
                    return -1;
                }
                else{
                    return 1;
                }
            }
        }
    }

    $("body").click(function(){
        sortTabel()
    });
</script>

七、数组去重的四种方法

方法一：推荐使用，通过添加到对象中，在查看是否存在

function remRepeatArr(arr){
    console.time("b");
    if(arr.length < 1){
        return false;
    }

    var arr = arr;
    var tempArr = [];
    var obj = {};
    for(var i= 0, len=arr.length; i<len; i++){
        obj[arr[i]] = 0;
    }

    for(var key in obj){
        tempArr.push(key);
    }

    console.timeEnd("b");
    return tempArr;
}

var ss = remRepeatArr([1,45,423,453,2,1,236,68,9,3,457,678,323,3,45,67,7,88,93,2,4]);
console.log(ss);

方法二：双重循环去匹配每个数，效率慢些

function delRepeatArr(arr){
    var res = [arr[0]];
    for(var i = 1; i < arr.length; i++){
        var repeat = false;
        for(var j = 0; j < res.length; j++){
            if(arr[i] == res[j]){
                repeat = true;
                break;
            }
        }
        if(!repeat){
            res.push(arr[i]);
        }
    }
    return res;
}

var arr = [112,112,34,'你好',112,112,34,'你好','str','str1'];
console.log(delRepeatArr(arr));

方法三：

function delRepeatArr(arr){
    arr.sort();    //先排序
    var res = [arr[0]];
    for(var i = 1; i < arr.length; i++){
        if(arr[i] !== res[res.length - 1]){
            res.push(arr[i]);
        }
    }
    return res;
}

var arr = [112,112,34,'你好',112,112,34,'你好','str','str1'];
console.log(delRepeatArr(arr));