javascript 排序方法

// 1、插入排序——直接插入排序
/**
 a、先将待排序序列的第1个元素看成是一个有序的子序列；
 b、从第2个元素开始，逐个将待排序的元素x与已排序序列[i-1] ~[0]（从后往前）进行比较；
 c、若x小于比较元素，则比较元素向后移动一位；否则，将x插入序列当前位置。
 * */
function insertSort(arr) {
  // 第一层循环：遍历待比较的数组元素
  for (let i = 1; i < arr.length; i++) {
    let temp = arr[i];
    // 第二层循环：将本轮带比较的元素与已经排序的元素相比较
    for (var j = i - 1; j >= 0 && arr[j] > temp; j--) {
      arr[j + 1] = arr[j];
    }
    //将插入元素插入到正确位置
    arr[j + 1] = temp;
  }
  return arr;
}

console.log(insertSort([12, 548, 2, 5478, 8852, 2145, 119]))


// 2、插入排序——希尔排序（最小增量排序）
/**
 a、先将要数组按某个增量d（n/2,n为要排序数的个数）分成若干组，所有距离为d的倍数的记录放在同一个组中；在各组内进行直接插入排序；
 b、然后再用一个较小的增量（d/2）对它进行分组，每组再进行直接插入排序；直至增量减为1，进行直接插入排序后，整体排序完成。
 * */
function shellSort(arr) {
  let n = arr.length,
      d = n;
  //第一层循环:分割增量d
  while (d > 1) {
    d = Math.floor(d / 2);
    // 下面；两层循环是直接插入排序
    for (var i = d; i < n; i++) {
      // 记录待比较的元素
      var temp = arr[i];
      for (var j = i - d; j >= 0 && arr[j] > temp; j = j - d) {
        arr[j + d] = arr[j];
      }
      arr[j + d] = temp;
    }
  }
  return arr;
}

console.log(shellSort([12, 548, 2, 5478, 8852, 2145, 119]))


// 3、选择排序——简单选择排序
/**
 * 每次遍历找到待排序元素中的最小值，将最小值和待排序的第一个元素交换，直至排序结束。
 * */
function directSelectSort(arr) {
  let minIndex, temp;
  for (var i = 0; i < arr.length; i++) {
    minIndex = i;
    //找到最小的值
    for (var j = i + 1; j < arr.length; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    //将最小的值与未排序的第一个元素进行交换
    temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }
  return arr;
}

console.log(directSelectSort([12, 548, 2, 5478, 8852, 2145, 119]))


// 4、选择排序——堆排序
/**
 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
 a、首先将长度为n的序列构建称为大顶堆，此时根节点一定是当前序列的最大值；
 b、取出当前大顶堆的根节点，将其与序列末尾元素进行交换；
 c、对交换后的n-1个序列元素进行调整，使其满足大顶堆的性质；
 d、重复b、c两个步骤，直至堆中只有1个元素为止。
 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列。
 * */
function heapSort1(arr) {
  len = arr.length;
  //建堆
  for (let i = Math.floor(len / 2); i >= 0; i--) {
    heapify(arr, i);
  }

  for (let i = len - 1; i > 0; i--) {
    //输出堆顶元素
    [arr[0], arr[i]] = [arr[i], arr[0]];
    len--;
    //重新调整堆
    heapify(arr, 0);
  }
  return arr;
}
// 调整堆
function heapify(arr, i) {
  var left = 2 * i + 1,
      right = 2 * i + 2,
      largest = i;
  if (left < len && arr[left] > arr[largest]) {
    largest = left;
  }
  if (right < len && arr[right] > arr[largest]) {
    largest = right;
  }
  if (largest !== i) {
    [arr[i], arr[largest]] = [arr[largest], arr[i]];
    heapify(arr, largest);
  }
}

console.log(heapSort1([12, 548, 2, 5478, 8852, 2145, 119]))


//  5、交换排序——冒泡排序
/**
 a、将序列中的相邻元素依次比较，较大的数向上冒（即交换到后面）；第一轮比较结束后，序列最后一个元素是当前序列的最大值。
 b、对序列当中剩下的n-1个元素再次执行步骤b，直至完成。共需要n-1轮比较。
 * */
function bubbleSort(arr) {
  let len = arr.length;
  //共需要n-1趟排序
  for (let i = 1; i < len; i++) {
    for (let j = 0; j < len - i; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]; //解构赋值进行交换
      }
    }
  }
  return arr;
}

console.log(bubbleSort([12, 548, 2, 5478, 8852, 2145, 119]))

//  6、改进的冒泡排序，记录上次交换的位置pos，避免对排好序的数据进行重复比较
/**
 a、从序列当中选择一个基准数（一般选第一个数）；
 b、遍历数组，小于基准的放在left，大于基准的放在right；
 c、递归。
 * */
function bubbleSort1(arr) {
  var pos = arr.length;     //初始化时无序元素的范围
  while (pos !== 0) {
    var bound = pos; //本趟无序元素的范围
    pos = 0;
    for (let i = 0; i < bound; i++) {
      if (arr[i] > arr[i + 1]) {
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]; //解构赋值进行交换
        pos = i;
      }
    }
  }
  return arr;
}

console.log(bubbleSort1([12, 548, 2, 5478, 8852, 2145, 119]))


// 7、归并排序
/**
 a、先将数组进行分组（折半拆分），直至子序列长度为1；
 b、然后再将子数组进行合并，关键点是实现两个数组的合并。
 * */
function merge(left, right) {
  var res = [];
  while (left.length > 0 && right.length > 0) {
    if (left[0] <= right[0]) {
      res.push(left.shift()); //删除第一个元素，并将其返回
    } else {
      res.push(right.shift());
    }
  }
  return res.concat(left, right);
}

function mergeSort(arr) {
  // 一直分到长度为1时，停止递归
  if (arr.length === 1) {
    return arr;
  }
  var mid = Math.floor(arr.length / 2);
  var left = arr.slice(0, mid);
  var right = arr.slice(mid);
  return merge(mergeSort(left), mergeSort(right));
}

console.log(mergeSort([12, 548, 2, 5478, 8852, 2145, 119]))


// 8、基数排序
/**
 1、MSD 从高位开始进行排序
 2、LSD 从低位开始进行排序：
 a、将所有待比较元素（正整数）统一为同样的数位长度，数位较短的数前面补零；
 b、从个位开始，进行排序；然后一次从低位到高位，进行排序；直至最高位完成排序。
 * */
function radixSort(arr, maxDigit) {   //maxDigit表示最大数字的位数
  var counter = [];
  var mod = 10;  //以十进制进行排序
  var dev = 1;
  for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
    for (var j = 0; j < arr.length; j++) {
      var bucket = parseInt((arr[j] % mod) / dev);
      if (counter[bucket] == null) {
        counter[bucket] = [];
      }
      counter[bucket].push(arr[j]);
    }
    var pos = 0;
    for (var j = 0; j < counter.length; j++) {
      var value = null;
      if (counter[j] != null) {
        while ((value = counter[j].shift()) != null) {
          arr[pos++] = value;
        }
      }
    }
  }
  return arr;
}

console.log(radixSort([12, 548, 2, 5478, 8853, 2145, 119], 4))