Detailed explanation of the use of sorting methods in JavaScript algorithms

In fact, it is relatively simple to implement array sorting in js using the sort method in the array:

1. Sorting

Simple Implementing array sorting

var arr = [];  
for(var i=0;i<20;i++){  
    arr.push(Math.floor(Math.random()*100))  
}  
arr.sort(function(a,b){  
    return a>b?1:-1;  
})  
alert(arr)

You cannot simply use the sort method. By default, the sort method sorts by ascii alphabetical order, not by numerical size as we think. The

sort() method can Accepts a method as a parameter. This method has two parameters. Represents the two array items for each sort comparison. When sort() sorts, this parameter will be executed every time when two array items are compared, and the two compared array

items will be passed to this function as parameters. When the function returns a value of 1, the order of the two array items is swapped, otherwise it is not swapped.

Array sorting of algorithm

var arr = [];  
for(var i=0;i<20;i++){  
    arr.push(Math.floor(Math.random()*100))  
}  
//生成一个无序的arr数组  
function sort(arr,start,end){  
    //数组长度为1  
    if(start == end ){  
        return [arr[start]]  
    }else if(start == end-1){  
        //数组长度为2，根据数值大小 来排序  
        if(arr[start]>arr[end]){  
            return [arr[end],arr[start]]  
        }else{  
            return [arr[start],arr[end]]  
        }  
    }  
    // 数组长度一半  
    var l = Math.floor((start+end)/2);  
    //左边数组  
    var arrLeft = sort(arr, start,l);  
    //右边数组  
    var arrRight = sort(arr,l+1,end);  
    //返回结果  
    var result = [];  
    //分割成两部分 左右两个数组 只比对数组中的第一个数，那个数值小就把谁放到结果里面，并把小的数值删除掉，固采用数组中的shift方法。一旦出现左边数组或右边数组，没有数据的时候  
    //result数组就与还有数据的数组合并 采用 concat,并返回结果  
    while(arrLeft.length>0 || arrRight.length>0){  
        if(arrLeft.length==0){  
            result = result.concat(arrRight);  
            break;  
        }else if(arrRight.length==0){  
            result = result.concat(arrLeft);  
            break;  
        }  
        if(arrLeft[0]<arrRight[0]){  
            result.push(arrLeft.shift())  
        }else{  
            result.push(arrRight.shift());  
        }  
    }  
    return result;  
}  
var arrSort = sort(arr,0,arr.length-1);//参数 数组，开始位置，结束位置  
document.write(arr+&#39;<br/>&#39;+arrSort);

Explanation: Array sorting mainly uses splitting the array into two until it can no longer be done. In the end, it can only be split into one or two arrays. Two, because the length of the array is divided into odd and even numbers. After splitting until there is only one or two in the final array, the sorting starts and the results are returned, and these results are compared one by one and merged. You may think why this method is so complicated. Can't you always use the first method? In fact, of course you can, but there is still the word performance in this world. When the data is tens, hundreds, hundreds, everyone's calculated results Time makes no difference. If the data is huge, hundreds of millions or billions, will we still have the confidence to use the first method? In fact, the algorithm of js is to divide and conquer, dividing many problems into small ones to solve.

The above is the detailed content of Detailed explanation of the use of sorting methods in JavaScript algorithms. For more information, please follow other related articles on the PHP Chinese website!