Explication détaillée de l'utilisation des méthodes de tri dans les algorithmes JavaScript

En fait, il est relativement simple d'implémenter le tri de tableau en js en utilisant la méthode de tri dans le tableau :

Tri

Implémentation simple du tri par tableau

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)

ne peut pas simplement utiliser la méthode de tri. Par défaut, la méthode de tri trie par ordre alphabétique ascii, et non par taille numérique comme nous le pensons,

sort(). La méthode peut accepter une méthode comme paramètre, et cette méthode a deux paramètres. Représente les deux éléments du tableau pour chaque comparaison de tri. Lors du tri sort(), ce paramètre sera exécuté à chaque fois que deux éléments du tableau sont comparés, et les deux éléments du tableau comparés

seront transmis à cette fonction en tant que paramètres. Lorsque la fonction renvoie une valeur de 1, l'ordre des deux éléments du tableau est inversé, sinon il n'est pas inversé.

Tri par tableau de l'algorithme

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

Explication : Le tri par tableau utilise principalement la division d'un tableau en deux jusqu'à ce que cela ne puisse plus être fait. Au final, il ne peut être divisé qu'en deux. Ou deux, car la longueur du tableau est divisée en nombres impairs et pairs. Après la division jusqu'à ce qu'il n'y en ait qu'un ou deux dans le tableau final, le tri commence et les résultats sont renvoyés, et ces résultats sont comparés un par un et fusionnés. . Vous vous demandez peut-être pourquoi cette méthode est si compliquée. Ne pouvez-vous pas toujours utiliser la première méthode ? En fait, bien sûr, vous pouvez, mais il y a toujours le mot performance dans ce monde. Lorsque les données sont des dizaines, des centaines, des centaines, celles de tout le monde. Résultats calculés Le temps ne fait aucune différence. Si les données sont énormes, des centaines de millions ou des milliards, avons-nous toujours la confiance nécessaire pour utiliser la première méthode ? En fait, l'algorithme de js consiste à diviser pour régner, divisant de nombreux problèmes en petits problèmes ? résoudre.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!