/**
* file Sort.js
* ide:vscode JavaScript Sorting Algorithms
* 插件：IntelliSense,JSDoc,CodeLens,Debugger for Chrome,
静态代码检查：ESLint,JSHint,Flow Langugae Support,StandardJS-JavaScript Standard Style,
koroFileHeader(文件头注释),
测试插件：Mocha sidebar,Mocha Test Explorer,Jest
Path Intellisense,Import Cost,Quokka.js,Code Metrics,Javascript Booster,Turbo Console Log
* https://www.programiz.com/dsa/counting-sort
* https://www.geeksforgeeks.org/sorting-algorithms/
* https://thedukh.com/2021/02/javascript-sorting-algorithms-explained-radix-sort/
* https://www.epubit.com/
* https://www.ituring.com.cn/
*/
/**
* Description placeholder 1. Bubble Sort冒泡排序法
* @date 10/23/2023 - 2:47:05 PM
*
* @param {*} arry 需要排序的整数數組
* @param {*} nszie 数组长度
* @returns {*} 返回排序后结果的数组
*/
function BubbleSort(arry, nszie)
{
var i, j, temp;
var swapped;
for (i = 0; i < nszie - 1; i++)
{
swapped = false;
for (j = 0; j < nszie - i - 1; j++)
{
if (arry[j] > arry[j + 1])
{
// Swap arry[j] and arry[j+1]
temp = arry[j];
arry[j] = arry[j + 1];
arry[j + 1] = temp;
swapped = true;
}
}
// IF no two elements were
// swapped by inner loop, then break
if (swapped == false)
break;
}
return arry
}
/**
* 交换操作
* @param {*} arry 数组
* @param {*} xp
* @param {*} yp
*/
function swap(arry,xp, yp)
{
var temp = arry[xp];
arry[xp] = arry[yp];
arry[yp] = temp;
}
/**
* 2 选择排序 Selection Sort
* @param {*} arry 需要排序的整数數組
* @param {*} nsize 数组长度
* @returns 返回排序后结果的数组
*/
function SelectionSort(arry, nsize)
{
var i, j, min_idx;
// One by one move boundary of unsorted subarray
for (i = 0; i < nsize-1; i++)
{
// Find the minimum element in unsorted array
min_idx = i;
for (j = i + 1; j < nsize; j++)
if (arry[j] < arry[min_idx])
min_idx = j;
// Swap the found minimum element with the first element
swap(arry,min_idx, i);
}
return arry;
}
/**
* 3 插入排序 Insertion Sort
* @param {*} arry 需要排序的整数數組
* @param {*} nsize 数组长度
* @returns 返回排序后结果的数组
*/
function InsertionSort(arry, nsize)
{
let i, key, j;
for (i = 1; i < nsize; i++)
{
key = arry[i];
j = i - 1;
/* Move elements of arr[0..i-1], that are
greater than key, to one position ahead
of their current position */
while (j >= 0 && arry[j] > key)
{
arry[j + 1] = arry[j];
j = j - 1;
}
arry[j + 1] = key;
}
return arry;
}
/**
* 整数数组转字符串显示
* @param {*} arry 需要打印的数组
* @param {*} nsize 数组的长度
*
* @returns 返回打印格式字符串
*/
function stringArray(arry, nsize)
{
var myStr=new Array();
var i;
for (i = 0; i < nsize; i++)
{
//getstr=getstr+arry[i].toString() + "<br/>";
myStr[i]=arry[i];
console.log(arry[i]);
}
console.log(myStr.join("<br/>"));
return myStr.join(" <br/>");
//console.log(arry);
/* var myStr=new Array();
var getstr="";
*/
/*
var i;
for (i = 0; i < nsize; i++)
{
getstr=getstr+arry[i] + " ";
myStr[i]=arry[i].toString();
console.log(myStr[i]);
}
return getstr;//myStr.join(" ");*/
}
//
// Merges two subarrays of arr[].
// First subarray is arr[l..m]
// Second subarray is arr[m+1..r]
/**
*
* @param {*} arry 需要打印的数组
* @param {*} indexStart
* @param {*} m
* @param {*} indexEnd
*/
function merge(arry, indexStart, m, indexEnd)
{
var n1 = m - indexStart + 1;
var n2 = indexEnd - m;
// Create temp arrays
var L = new Array(n1);
var R = new Array(n2);
// Copy data to temp arrays L[] and R[]
for (var i = 0; i < n1; i++)
L[i] = arry[indexStart + i];
for (var j = 0; j < n2; j++)
R[j] = arry[m + 1 + j];
// Merge the temp arrays back into arry[l..r]
// Initial index of first subarray
var i = 0;
// Initial index of second subarray
var j = 0;
// Initial index of merged subarray
var k = indexStart;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arry[k] = L[i];
i++;
}
else {
arry[k] = R[j];
j++;
}
k++;
}
// Copy the remaining elements of
// L[], if there are any
while (i < n1) {
arry[k] = L[i];
i++;
k++;
}
// Copy the remaining elements of
// R[], if there are any
while (j < n2) {
arry[k] = R[j];
j++;
k++;
}
}
// l is for left index and r is
// right index of the sub-array
// of arr to be sorted
/**
* 4 合并排序 Merge Sort
* @param {*} arry 需要排序的整数數組
* @param {*} indexStart 数组索引值 0
* @param {*} indexEnd 索引值最大值 数组长度-1
* @returns 返回排序好的数组
*/
function mergeSort(arry,indexStart, indexEnd){
if(indexStart>=indexEnd){
return;
}
var m =indexStart+ parseInt((indexEnd-indexStart)/2);
mergeSort(arry,indexStart,m);
mergeSort(arry,m+1,indexEnd);
merge(arry,indexStart,m,indexEnd);
return arry;
}
/**
* Function to partition the array and return the partition index
* @param {*} arry 需要排序的整数數組
* @param {*} low 数组索引值 0
* @param {*} high 索引值最大值 数组长度-1
* @returns
*/
function quickPartition(arry, low, high) {
// Choosing the pivot
let pivot = arry[high];
// Index of smaller element and indicates the right position of pivot found so far
let i = low - 1;
for (let j = low; j <= high - 1; j++) {
// If current element is smaller than the pivot
if (arry[j] < pivot) {
// Increment index of smaller element
i++;
[arry[i], arry[j]] = [arry[j], arry[i]]; // Swap elements
}
}
[arry[i + 1], arry[high]] = [arry[high], arry[i + 1]]; // Swap pivot to its correct position
return i + 1; // Return the partition index
}
/**
* The main function that implements QuickSort
* 5 Quick Sort 快速排序
* @param {*} arry 需要排序的整数數組
* @param {*} low 数组索引值 0
* @param {*} high 索引值最大值 数组长度-1
* @returns 返回排序好的数组
*/
function quickSort(arry, low, high) {
if (low < high) {
// pi is the partitioning index, arr[pi] is now at the right place
let pi = quickPartition(arry, low, high);
// Separately sort elements before partition and after partition
quickSort(arry, low, pi - 1);
quickSort(arry, pi + 1, high);
}
return arry;
}
/**
* of Heap Sort
* 6 堆排序 Heap Sort
* @param {*} arry 需要排序的整数數組
* @returns 返回排序好的数组
*/
function heapSort( arry)
{
var N = arry.length;
// Build heap (rearrange array)
for (var i = Math.floor(N / 2) - 1; i >= 0; i--)
heapify(arry, N, i);
// One by one extract an element from heap
for (var i = N - 1; i > 0; i--) {
// Move current root to end
var temp = arry[0];
arry[0] = arry[i];
arry[i] = temp;
// call max heapify on the reduced heap
heapify(arry, i, 0);
}
return arry;
}
/**
* To heapify a subtree rooted with node i which is
* an index in arr[]. n is size of heap
* @param {*} arry 需要排序的整数數組
* @param {*} N 数组长度
* @param {*} i 数组索引值 0
*/
function heapify(arry, N, i)
{
var largest = i; // Initialize largest as root
var l = 2 * i + 1; // left = 2*i + 1
var r = 2 * i + 2; // right = 2*i + 2
// If left child is larger than root
if (l < N && arry[l] > arry[largest])
largest = l;
// If right child is larger than largest so far
if (r < N && arry[r] > arry[largest])
largest = r;
// If largest is not root
if (largest != i) {
var swap = arry[i];
arry[i] = arry[largest];
arry[largest] = swap;
// Recursively heapify the affected sub-tree
heapify(arry, N, largest);
}
}
/**
* 7 Counting Sort 计数排序
* @param {*} arry 需要排序的整数數組
* @param {*} min 数组中最小的值
* @param {*} max 数组中最大的值
* @returns 返回排序好的数组
*/
function countingSort(arry, min, max) {
let j = 0;
let supplementary = [];
for (let i = min; i <= max; i++) {
supplementary[i] = 0;
}
for (let i=0; i < arry.length; i++) {
supplementary[arry[i]] += 1;
}
for (let i = min; i <= max; i++) {
while (supplementary[i] > 0) {
arry[j++] = i;
supplementary[i] -= 1;
}
}
return arry;
}
/**
* 7 Counting Sort 计数排序
* @param {*} arry 需要排序的整数數組
* @returns 返回排序好的数组
*/
function duCountingSort(arry) {
let j = 0;
let supplementary = [];
min=getArrayMin(arry);
max=getArrayMax(arry);
for (let i = min; i <= max; i++) {
supplementary[i] = 0;
}
for (let i=0; i < arry.length; i++) {
supplementary[arry[i]] += 1;
}
for (let i = min; i <= max; i++) {
while (supplementary[i] > 0) {
arry[j++] = i;
supplementary[i] -= 1;
}
}
return arry;
}
/**
* 求得数组中最大值
* @param {*} arry 整数數組
* @param {*} nszie 数组长度
* @returns 返回数组中的最大值
*/
function getMax(arry,nszie)
{
let mx = arry[0];
for (let i = 1; i < nszie; i++)
if (arry[i] > mx)
mx = arry[i];
return mx;
}
/**
* 求得数组中最小值
* @param {*} arry 整数數組
* @returns 返回数组中的最小值
*/
function getArrayMin(arry){
var min = arry[0];
for(var i = 1, ilen = arry.length; i < ilen; i+=1) {
if(arry[i] < min) {
min = arry[i];
}
}
return min;
}
/**
* 求得数组中最大值
* @param {*} arry 整数數組
* @returns 返回数组中的最大值
*/
function getArrayMax(arry) {
var max = arry[0];
for(var i = 1,ilen = arry.length; i < ilen; i++) {
if(arry[i] > max) {
max = arry[i];
}
}
return max;
}
/**
*
* @param {*} arry
* @param {*} nszie
* @param {*} exp
*/
function radixCountSort(arry,nszie,exp)
{
let output = new Array(nszie); // output array
let i;
let x;
let count = new Array(10);
for(let i=0;i<10;i++)
count[i]=0;
// Store count of occurrences in count[] 这里有问题
for (i = 0; i < nszie; i++)
{
let s=arry[i]/exp;
x = Math.floor(s) % 10;
}
count[x]++;
// Change count[i] so that count[i] now contains
// actual position of this digit in output[]
for (i = 1; i < 10; i++)
count[i] += count[i - 1];
// Build the output array
for (i = nszie - 1; i >= 0; i--) {
output[count[x] - 1] = arry[i];
count[x]--;
}
// Copy the output array to arr[], so that arr[] now
// contains sorted numbers according to current digit
for (i = 0; i < nszie; i++)
arry[i] = output[i];
}
/**
* The main function to that sorts arr[] of size n using
8 Radix Sort 基数排序 Radix Sort 有问题
* @param {*} arry 需要排序的整数數組
* @param {*} nszie 数组长度
*/
function radixsort(arry,nszie)
{
// Find the maximum number to know number of digits
let m = getMax(arry, nszie);
// Do counting sort for every digit. Note that
// instead of passing digit number, exp is passed.
// exp is 10^i where i is current digit number
for (let exp = 1; Math.floor(m / exp) > 0; exp *= 10)
radixCountSort(arry, nszie, exp);
return arry;
}
/**
*
* @param {*} arry
* @returns
*/
function getBiggestDigitCount(arry) {
let maxDigits = 0;
for (let i = 0; i < arry.length; i++) {
maxDigits = Math.max(maxDigits, arry[i].toString().length);
}
return maxDigits;
}
/**
*
* @param {*} arry
* @param {*} i
* @returns
*/
function getDigitAtPlace(arry, i) {
return arry.toString().split("").reverse()[i] || 0;
}
/**
* 8 Radix Sort 基数排序
* @param {*} arry 需要排序的整数數組
* @returns 返回排序后结果的数组
*/
function DuRadixSort(arry) {
let maxDigits = getBiggestDigitCount(arry);
for (let i = 0; i < maxDigits; i++) {
let bucketArray = Array.from({ length: 10 }, () => []);
for (let j = 0; j < arry.length; j++) {
let digit = getDigitAtPlace(arry[j], i);
bucketArray[digit].push(arry[j]);
}
arry = [].concat(...bucketArray);
}
return arry;
}
/**
* 9. Bucket Sort 桶排序
* using bucket sort
* @param {*} arry 需要排序的整数數組
* @param {*} nszie 数组长度
* @returns 返回排序后结果的数组
*/
function bucketSort(arry,nszie)
{
if (nszie <= 0)
return;
// 1) Create n empty buckets
let buckets = new Array(nszie);
for (let i = 0; i < nszie; i++)
{
buckets[i] = [];
}
// 2) Put array elements in different buckets
for (let i = 0; i < nszie; i++) {
let idx = arry[i] * nszie;
let flr = Math.floor(idx);
//buckets[flr].push(arry[i]); //有问题
buckets[flr].push(arry[i]);
}
// 3) Sort individual buckets
for (let i = 0; i < nszie; i++) {
buckets[i].sort(function(a,b){return a-b;});
}
// 4) Concatenate all buckets into arr[]
let index = 0;
for (let i = 0; i < nszie; i++) {
for (let j = 0; j < buckets[i].length; j++) {
arry[index++] = buckets[i][j];
}
}
return arry;
}
/**
* 9. Bucket Sort 桶排序
* @param {*} arry 需要排序的整数數組
* @returns 返回排序后结果的数组
*/
function duBubbleSort(arry) {
let swapHappened;
for (let i = arry.length; i > 0; i--) {
swapHappened = true;
for (let j = 0; j < i - 1; j++) {
if (arry[j] > arry[j + 1]) {
[arry[j], arry[j + 1]] = [arry[j + 1], arry[j]];
swapHappened = false;
}
}
if (swapHappened) {
break;
}
}
return arry;
}
/**
*
* @param {*} arry
* @returns
*/
function bingoSort(arry) {
let n=arry.length;
let bingo = arry[0];
let nextBingo = arry[0];
// For finding the maximum and minimum element of
// the Array
for (let i = 1; i < n; bingo = Math.min(bingo, arry[i]), nextBingo = Math.max(nextBingo, arry[i]), i++)
;
let largestEle = nextBingo;
let nextElePos = 0;
while (bingo < nextBingo)
{
// Will keep the track of the element position to
// shifted to their correct position
let startPos = nextElePos;
for (let i = startPos; i < n; i++) {
if (arry[i] == bingo) {
[arry[i], arry[nextElePos]] = [arry[nextElePos], arry[i]];
nextElePos = nextElePos + 1;
}
// Here we are finding the next Bingo Element
// for the next pass
else if (arry[i] < nextBingo)
nextBingo = arry[i];
}
bingo = nextBingo;
nextBingo = largestEle;
}
for (let i = 0; i < arry.length; i++) {
// console.log("arr: ",arry[i]);
}
return arry;
}
/**
* 打印数组
* @param {*} arry 需要找印的数组
* @param {*} nsize 数组长度
* @returns 返回打印的格式字符串
*/
function printArray(arry, nsize)
{
var getstr="";
var i;
for (i = 0; i < nsize; i++)
{
console.log(arry[i] + " ");
getstr=getstr+arry[i]+" ";
}
return getstr;
}
调用：
<!--
* @Author: error: error: git config user.name & please set dead value or install git && error: git config user.email & please set dead value or install git & please set dead value or install git
* @Date: 2023-10-23 12:26:05
* @LastEditors: error: error: git config user.name & please set dead value or install git && error: git config user.email & please set dead value or install git & please set dead value or install git
* @LastEditTime: 2023-10-23 17:22:26
* @FilePath: \algorithms\1.html alt+ctrl+i 键
* @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
-->
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1.0,maximum-scale=1.0,minimum-scale=1.0,user-scalable=no">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>成长开始，geovindu,涂聚文，Geovin Du Bubble Sort冒泡排序法</title>
<meta name="Description" content="geovindu"/>
<meta name="Keywords" content="geovindu"/>
<meta name="author" content="geovindu"/>
<script src="js/jquery-3.6.0.js"></script>
<script src="js/SortAlgorithm/Sort.js"></script>
<script type="text/javascript">
$(document).ready(function () {
// 1. Bubble Sort冒泡排序法
var arry = [ 64, 34, 25, 112, 220, 11, 90 ];
var nzie= arry.length;
var duselect=SelectionSort(arry,nzie);
console.log(duselect)
var geovindu=BubbleSort(arry, nzie);
console.log(geovindu);
var inserttdu=InsertionSort(arry,nzie);
var myStr=new Array();
var i;
for (i = 0; i < nzie; i++)
{
//getstr=getstr+arry[i].toString() + "<br/>";
myStr[i]=geovindu[i].toString();
console.log(geovindu[i].toString());
}
console.log(myStr.join("<br/>"));
var du=stringArray(arry,nzie);
var du2=stringArray(duselect,nzie);
var du3=stringArray(inserttdu,nzie);
var dumergeSort=mergeSort(arry,0,nzie-1);
var du4=stringArray(dumergeSort,nzie);
console.log("mergesoft:"+dumergeSort);
var duQuick=quickSort(arry,0,nzie-1);
var du5=stringArray(duQuick,nzie);
var duHeap=heapSort(arry,0,nzie-1);
var du6=stringArray(duHeap,nzie-1);
var duCounting=duCountingSort(arry);
var du7=stringArray(duCounting,nzie);
let duarry=[170, 45, 75, 90, 802, 24, 2, 66];
var duradix=DuRadixSort(duarry);
var du8=stringArray(duradix,nzie);
let arrdu = [0.897, 0.565,
0.656, 0.1234,
0.665, 0.3434];
var dubucket=duBubbleSort(arrdu);
var du9=stringArray(dubucket,nzie);
var dubingo=bingoSort(arry);
var du10=stringArray(dubingo,nzie);
console.log("bucket Sort:"+dubucket);
console.log(du8);
console.log(du);
console.log("Bubble Sorted array: ");
var getstr=printArray(arry, nzie);
console.log("str:"+getstr)
$("#txtgeovindu").html(getstr);
txtgeovindu.innerHTML = getstr;//stringArray(geovindu,nsize);
$("#geovindu").html("1.泡冒泡排序Bubble Sorted：<br/>"+myStr.join("<br/>"));
$("#geovindu2").html(du);
$("#geovindu3").html("2.选择排序Selection Sorted：<br/>"+du2);
$("#geovindu4").html("3.插入排序Insertion Sorted：<br/>"+du3);
$("#geovindu5").html("4.合并排序 Merge Sort ：<br/>"+du4);
$("#geovindu6").html("5.快速排序 Quick Sort：<br/>"+du5);
$("#geovindu6").html("6.堆排序 Heap Sort：<br/>"+du6);
$("#geovindu7").html("7.计数排序 Counting Sort：<br/>"+du7);
$("#geovindu8").html("8.基数排序 Radix Sort：<br/>"+du8);
$("#geovindu9").html("9.桶排序 Bucket Sort：<br/>"+du9);
$("#geovindu10").html("10.宾果排序 Bingo Sort：<br/>"+du10);
});
</script>
</head>
<body>
<textarea id="txtgeovindu" class="geovindu" name="" cols="30" rows="10"></textarea>
<div id="geovindu"></div>
<div id="geovindu2"></div>
<div id="geovindu3"></div>
<div id="geovindu4"></div>
<div id="geovindu5"></div>
<div id="geovindu6"></div>
<div id="geovindu7"></div>
<div id="geovindu8"></div>
<div id="geovindu9"></div>
<div id="geovindu10"></div>
</body>
</html>
输出：
标签：Sorting,++,javascript,param,Algorithms,数组,var,let,arry From： https://www.cnblogs.com/geovindu/p/17783311.html