前端的排序算法總結

參考lianjie

冒泡排序

典型的排序方法，命名來自魚呼吸時吹出的氣泡，上層的氣泡老是最大的。

思路：兩層循環，內層循環對比相鄰兩個數據（j,j+1），假設j > j + 1則交換元素位置。
外層循環爲長度限制，在內層第一次循環完成後減小長度1（由於最後一個泡已經固定，爲這個數組的最大值）

function bubbleSort(arr){
  for(let i = 0; i < arr.length - 1; i++){
    let flag = false;
    for(let j = 0; j < arr.length - i - 1; j++){
      if(arr[j] > arr[j + 1]){
          let temp = arr[j];
          arr[j] = arr[j+1];
          arr[j+1] = temp;;
          flag = true;
      }
    }
    if(!flag){
      break;
    }
  }
  return arr;
}

加一個標誌位flag，若是沒有進行交換，將標誌位置爲false，表示排序完成。

• 時間複雜度O(n^2)，最優狀況下是O(n)
• 空間複雜度O(1)

選擇排序

顧名思義，每次都選擇最小的，而後交換位置

思路：兩層循環，內層循環爲選取第一個位置的值，而後將它與剩下的值做對比，獲得比它小的則交換位置。外層循環爲控制第一位值的固定（一次循環後，第一位則爲該數組最小的值，下一次循環沒必要帶上）。

function selectionSort(arr){
  for(let i = 0; i < arr.length - 1; i++){
    let index = i;
    for(let j = i+1; j < arr.length; j++){
    //判斷是否有小於當前值，有則交換位置
      if(arr[index] > arr[j]){
        index = j;
      }
    }
      let temp = arr[i];
      arr[i] = arr[index ];
      arr[index] = temp;
  }
  return arr;
}

• 時間複雜度：O(n^2)，屬於不穩定的算法（每次交換以後，它都改變了後續數組的順序）
• 空間複雜度：O(1)

快速排序

思路：二分法，先找一個基數，分隔出以基數爲界的左右兩個數組，而後遞歸重複這個步驟，直到分組剩餘一個數，則咱們認爲已經排列完成。

function quickSort(arr){
  if(arr.length <= 1){
    return arr;
  }
  let temp = arr[0];
  const left = [];
  const right = [];
  for(var i = 1; i < arr.length; i++){
    if(arr[i] > temp){
      right.push(arr[i]);
    }else{
      left.push(arr[i]);
    }
  }
  return quickSort(left).concat([temp], quickSort(right));
}

• 時間複雜度：O(n*logn)，屬於不穩定的算法,特殊狀況下會是O(n^2)
• 空間複雜度：輔助空間是logn，因此空間複雜度爲O(logn)