Algorithmes courants implémentés en Javascript (tels que bulle, rapide, casier, impair-pair, etc.)_compétences Javascript

Copier le code Le code est le suivant :

l = [6, 2, 4, 1, 98, 34, 5, 9, 23, 8, 10, 32]

       
//冒泡排序
/*function bubbleSort(arr) {
    newarr = arr.slice()
    if (newarr.length <= 2) return newarr
    for (var i = 0; i < newarr.length - 1; i ) {
        pour (var j = 0; j < newarr.length - i - 1; j ) {
           si (newarr[j] > newarr[j 1]) {
newarr[j] = [newarr[j 1], newarr[j 1] = newarr[j]][0]

            }
        }
    }
    retourner newarr
}

console.log(l)
result = bubbleSort(l)
console.log(result)*/

       
//快速排序
/* function quickSort(arr) {
    if (arr.length <= 1) return arr;
    var left = [],
        right = [],
        middle = [];
var mid = arr[Math.floor(arr.length / 2)]
    for (var i = 0; i < arr.length; i ) {
        if (arr[i] < mid) {
            left.push(arr[i]);
         } else if (arr[i] > mid) {
            right.push(arr[i]);
        } else {
            middle.push(mid);
        }
    }
    return [].concat(quickSort(gauche), middle, quickSort(droite))

}

var results = quickSort(l)
console.log(results)

       
*/

//选择排序
/*function selectSort(arr) {
    var min = 9999,
        minindex = 0;
    var left = [],
        right = arr.slice();
    if (arr.length <= 1) return arr;
    pour (var i = 0; je &Lt ; longueur d'arr.; i ) {
        if (arr[i] <= min) {
            min = arr[i];
            minindex = i;
        }
    }
    left.push( min);   
    right.splice(minindex, 1);
    return [].concat(left, selectSort(right))
}

       
var results = selectSort(l)
console.log(results)*/

       
//插入排序
/*function insertSort(arr) {
    var tmp;
    for (var i = 1; i < arr.length; i ) {
        tmp = arr[i];
        pour (var j = i; j > 0; j--) {
            si (arr[j - 1] > tmp) {
               arr[j] = arr[j - 1];
            } else {
                pause ;
            }
         }
        arr[j] = tmp;
    }
    return arr;
}

var results = insertSort(l)
console.log(results)*/

//木桶排序
/*function bucketSort(arr){
    var bucket = [];
    var newarr = [];
    for (var i = 0; i < arr.length; i ) {
seau[arr[i]] = arr[i];
    }
    for (var i = 0; i < bucket.length; i ) {
        if (bucket[i] !== undefined){
            newarr.push(bucket[i])
}
    }
    return newarr;
}

var results = bucketSort(l)
console.log(results)*/

//鸽巢排序,非负整数
/*function pigeonholeSort(arr){
    var tempArr = [];
    for(var i=0,l=arr.length;i tempArr[arr[i]] = (tempArr[arr[i]] 1)||1 ;
    }

    var result = [],count;
    for(var k=0; k        count = tempArr[k];
        if(count){
            for(var i=0;i                result.push (k);
            }
         }     
    }

    retourner le résultat ;   
}

var results = pigeonholeSort(l)
console.log(results)*/

//归并排序
/*function mergeSort(arr) {
    if (arr.length <= 1) return arr;
    var mid = Math.floor(arr.length / 2);
    var left = MergeSort(arr.slice(0, mid));
    var right = MergeSort(arr.slice(mid));
    var result = [];

    while (left.length && right.length) {
        if (left[left .length - 1] <= right[0]) {
            result = result.concat(left);
            left = [];
         } sinon if (right[right.length - 1] < ; left[0]) {
            result = result.concat(right);
            right = [];
        } else {
            if (right[0] < left[0]) {

    }
    résultat = result.concat(gauche, droite);

    retourner le résultat;
}*/

       

/*function mergeSort(arr) {
    var fusionner = function(gauche, droite) {
        var résultat = [];
        while (left.length > 0 && droite.longueur > 0) {
            if (left[0] < right[0]) {
                result.push(left.shift());
            } else {
                result.push(right.shift ());
            }
        }
        return result.concat(left).concat(right);
    }

    if (arr.length == 1) return arr;
    var middle = Math.floor(arr.length / 2),
        left = arr.slice(0, middle),
        right = arr.slice(middle);
    return merge(mergeSort) (à gauche), mergeSort(à droite));
}

var results = mergeSort(l)
console.log(results)

*/

       
//堆排序

/ *function heapSort(arr) {
    var findRoot = function(arr, p, length) {
        p = p || 0;
        longueur = longueur || arr.length;
        var self = arguments.callee;
        var l = p * 2 1;
        var r = (p 1) * 2;
         var gauche, droite;

        si (l < longueur) gauche = soi (arr, l, longueur);
        si (r < longueur) droite = soi (arr, r, longueur);
        si (gauche > arr [p]) arr[p] = [gauche, arr[l] = arr[p]][0];
        si (droite > arr[p]) arr[p] = [droite, arr[r ] = arr[p]][0];

        retourner arr[p];
    };

       
    pour (var i = arr.length; i > 0 ; i--) {
        findRoot(arr, 0, i);
        arr[i - 1] = [arr[0], arr[0] = arr[i - 1]][0];
    }
    return arr;
}

var results = heapSort(l)
console.log(results)*/

       

//奇偶排列

/*function oddEvenSort(arr) {
    var swaped = true,
        k = 0;
    while (permuté) {
        if (k > 0 ) swaped = false;

        for (var i = k; i < arr.length - 1; i = 2) {
            if (arr[i]>arr[i 1]) {
               arr[i] = [ arr[i 1], arr[i 1]=arr[i] ][0];
               swaped = true;
            }
        >
        k = [1, 0][k]
    }
    return arr;
}

var résultats = oddEvenSort(l)
console.log(results)*/

function oddEvenSort(arr) {
    var swaped = true;
    while (swaped) {
        swaped = false;
        for (var i = 0; je &Lt ; longueur d'arr.; i = 2) {
            if (arr[i] > arr[i 1]) {
               arr[i] = [arr[i 1], arr[i 1] = arr[i]][ 0];
                swaped = true;
            >
            for (var i = 1; i < arr.length; i = 2) {
            if (arr[ je] > ; arr[i 1]) {
                arr[i] = [arr[i 1], arr[i 1] = arr[i]][0];
               swaped = true;
            }
        }
    }
    return arr;
}

var results = oddEvenSort(l)
console.log(results)