javascript： Sorting Algorithms

/**
* 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() + "
";
      myStr[i]=arry[i];
      console.log(arry[i]);
  }
   console.log(myStr.join("
"));
    return myStr.join(" 
");
  //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;
}

调用：

输出：