JavaScript implementation of commonly used algorithms (such as bubble, fast, pigeon nest, parity, etc.) _javascript skills

Copy Code code as follows:

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


Bubble sort
/*function Bubblesort (arr) {
Newarr = Arr.slice ()
if (newarr.length <= 2) return Newarr
for (var i = 0; i < newarr.length-1; i++) {
for (var j = 0; J < newarr.length-i-1; j +) {
if (Newarr[j] > newarr[j + 1]) {
NEWARR[J] = [Newarr[j + 1], newarr[j + 1] = newarr[j]][0]

}
}
}
Return Newarr
}

Console.log (L)
result = Bubblesort (l)
Console.log (Result) * *


Quick Sort
/*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 (left), middle, quickSort (right))

}

var results = QuickSort (l)
Console.log (Results)


*/

Select sort
/*function Selectsort (arr) {
var min = 9999,
Minindex = 0;
var left = [],
right = Arr.slice ();
if (arr.length <= 1) return arr;
for (var i = 0; i < arr.length; 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) * *


Insert Sort
/*function Insertsort (arr) {
var tmp;
for (var i = 1; i < arr.length; i++) {
TMP = Arr[i];
for (var j = i; j > 0; j--) {
if (Arr[j-1] > tmp) {
ARR[J] = arr[j-1];
} else {
Break
}
}
ARR[J] = tmp;
}
return arr;
}

var results = Insertsort (l)
Console.log (Results) * *

Wooden bucket Sort
/*function Bucketsort (arr) {
var bucket = [];
var newarr = [];
for (var i = 0; i < arr.length; i++) {
Bucket[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) * *

Pigeon-nest sort, nonnegative integer
/*function Pigeonholesort (arr) {
var temparr = [];
for (Var i=0,l=arr.length;i<l;i++) {
Temparr[arr[i]] = (temparr[arr[i]]+1) | | 1;
}

var result = [],count;
for (Var k=0;k<temparr.length;k++) {
Count = Temparr[k];
if (count) {
for (Var i=0;i<count;i++) {
Result.push (k);
}
}
}

return result;
}

var results = Pigeonholesort (l)
Console.log (Results) * *

Merge sort
/*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 = [];
else if (Right[right.length-1] < left[0]) {
result = Result.concat (right);
right = [];
} else {
if (Right[0] < left[0]) {
Result.push (Right.shift ());
} else {
Result.push (Left.shift ());
}
}
}
result = Result.concat (left, right);

return result;
}*/



/*function MergeSort (arr) {
var merge = function (left, right) {
var result = [];
while (left.length > 0 && right.length > 0) {
if (Left[0] < right[0]) {
Result.push (Left.shift ());
} else {
Result.push (Right.shift ());
}
}
Return Result.concat-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 (left), MergeSort (right));
}

var results = MergeSort (l)
Console.log (Results)

*/


Heap Sort

/*function Heapsort (arr) {
var findRoot = function (arr, p, length) {
p = P | | 0;
Length = Length | | Arr.length;
var self = Arguments.callee;
var L = p * 2 + 1;
var r = (p + 1) * 2;
var left, right;

if (l < length) left = self (arr, l, length);
if (r < length) right = self (arr, r, length);
if (Left > Arr[p]) arr[p] = [Left, arr[l] = arr[p]][0];
if (right > Arr[p]) arr[p] = [Right, arr[r] = arr[p]][0];

return arr[p];
};


for (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) * *



Parity arrangement

/*function Oddevensort (arr) {
var swaped = True,
k = 0;
while (swaped) {
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 results = Oddevensort (l)
Console.log (Results) * *

function Oddevensort (arr) {
var swaped = true;
while (swaped) {
swaped = false;
for (var i = 0; i < arr.length 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[i] > 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)