// 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))