這是一個有效的插入排序算法嗎？ 還是冒泡排序？ 我糊塗了

Question

 let swapFun = (arrToSwap, indexFir, indexSec) => { let temp = arrToSwap[indexFir] arrToSwap[indexFir] = arrToSwap[indexSec] arrToSwap[indexSec] = temp } let insertionSort = (arr, n = 0) => { if (n === arr.length) { return arr } for (let i = 1; i < arr.length; i++) { while (arr[i - 1] > arr[i]) { swapFun(arr, i - 1, i) } } insertionSort(arr, n + 1) return arr } console.log(insertionSort([5, 4, 33, 2, 8]))

Answer 1

它實際上是冒泡排序，但它是冒泡排序的糟糕實現。

如果您注意到 for 循環：

for (let i = 1; i < arr.length; i++) {

   while (arr[i - 1] > arr[i]) {
      swapFun(arr, i - 1, i)
   }

}

它基本上迭代數組，從索引 1 開始，到數組的末尾，並且對於每個項目，它將項目與前一個項目進行比較。 比較是在 while 循環中進行的，但它實際上不是循環（如果索引 i-1 處的項目大於索引 1 處的項目，它只是執行主體。）它可以用 if 語句替換：

    for (let i = 1; i < arr.length; i++) {

      if (arr[i - 1] > arr[i]) {
        swapFun(arr, i - 1, i)
      }

    }

for循環在全部n-1的時間執行，因為Ñ在開始= 0和每個函數被遞歸調用時間被遞增，直到它達到N =陣列長度（此時為循環將不被執行。）在for 循環的主體被執行array.length-1 次（在你的例子中是 4 次）。

這個實現的最大問題是使用 Recursion ，它會使用更多的空間（因為 Recursion 使用堆棧）。 它也沒有針對時間進行優化。 即使數組已經排序，for 循環也將執行N-1 次，其主體也將執行N-1 次。 這意味着即使在最好的情況下（數組已經排序），這種冒泡排序的時間復雜度也是O(n^2) ，而實際上它可以是 O(n)。

冒泡排序的優化版本：

const sort = array => {
  let isSorted;
  for (let i=0; i < array.length; i++) {
      isSorted = true;
      for (let j=1; j < array.length - i; j++)
          if ( array[j] < array[j-1]) {
              swap(array, j, j-1);
              isSorted = false;
          }
      if (isSorted)
          return;
  }
}

const swap = (array, index1, index2) => {
  let temp = array[index1];
  array[index1] = array[index2];
  array[index2] = temp;
}

const array = [5, 4, 33, 2, 8]
sort(array);
console.log(array);

變量“isSorted”跟蹤數組是否已排序。 如果沒有進行交換，則表示數組已排序，我可以停止執行該函數。 還要注意在內循環中： for (let j=1; j < array.length - i; j++) ，我們不檢查“排序部分”的項目（每次執行內循環時，都會有一個項目它是數組中的“最終”索引，我們不需要與這些項目進行任何比較）。

希望這有幫助！ 請問我是否沒有正確解釋某些事情。