js 插入排序、快速排序、深度優先遍歷、廣度優先遍歷

查資料的時候發現V8引擎 array.sort() 主要使用了兩種排序：插入排序、快速排序，這裏就實現一下這兩種排序(長度小於 10 的使用插排，大於10的使用快排)

插入排序

先把第一個值當做一個獨立的有序的數組(只有一個的時候，肯定是有序的)

然後獲取接下來的值，經過對比之後，在那個有序的數組插入對應的值

function InsertionSort(a, from, to) {
  for (var i = from + 1; i < to; i ++) {
    var element = a[i];
    // 將 a[i] 和之前已經 變成有序的 那一點進行比較，然後插入
    // 已經有序的 隊列從 a[0] 開始，只有一個的情況之下肯定是有序的
    // 接着開始查找第二個元素，然後第二個元素和已經存在的 有序的 隊列進行對比，決定要插入哪裏，以此類推
    for (var j = i - 1; j >= from; j --) {
      var tmp = a[j];
      // 用戶自己寫的 判斷，或者系統自定義的判斷
      // 從後面排起，當大於當前需要判斷的值，就往後移一個(第一個 j + 1 指的就是 element 的位置)
      var order = comparefn(tmp, element);
      if (order > 0) {
        // 把位置一個一個地往後面挪
        // array.splice() 函數能夠很好地完成
        a[j + 1] = tmp;
      } else {
        break;
      }
    }
    // 最後才把值插入正確的位置
    a[j + 1] = element;
  }
}

function comparefn(a, b) {
  console.log(a, b);
  return b - a;
}

var arr = [5, 3, 1, 6, 4];
InsertionSort(arr, 0, arr.length);
console.log(arr);

這裏可以使用 array.splice 來進行操作

function InsertionSort(a, from, to) {
  var arr = [a[from]];
  for (var i = from + 1; i < to; i++) {
    // debugger;
    var element = a[i];
    // 將 a[i] 和之前已經 變成有序的 那一點進行比較，然後插入
    // 已經有序的 隊列從 a[0] 開始，只有一個的情況之下肯定是有序的
    // 接着開始查找第二個元素，然後第二個元素和已經存在的 有序的 隊列進行對比，決定要插入哪裏，以此類推
    for (var j = arr.length - 1; j >= 0; j--) {
      var tmp = arr[j];
      // 用戶自己寫的 判斷，或者系統自定義的判斷
      // 從後面排起，當大於當前需要判斷的值，就往後移一個(第一個 j + 1 指的就是 element 的位置)
      var order = comparefn(tmp, element);
      if (order < 0) {
        break;
      }
    }
    // 最後才把值插入正確的位置
    // a[j + 1] = element;
    arr.splice(j + 1, 0, element);
  }
  return arr;
}
function comparefn(a, b) {
  return b - a;
}

var ar = [5, 3, 1, 6, 4, 4, 10, 5];
var newArr = InsertionSort(ar, 0, ar.length);
console.log(newArr);  

快速排序：

將第一個數作爲基準，然後將所有小於他的數放左邊，所有大於他的數放右邊

接着完成第一輪之後，左右邊各位一個數組，重新調用 快速排序

    let num = 0;
    var a = [34, 12, 56, 12, 46, 112, 8, 6, 17, 34];
    function quickSort(left, right) {
      let i, j, temp;
      temp = a[left];
      i = left;
      j = right;
      while (i != j) {
        while (a[j] >= temp && i < j) { //向左移 j，直到遇到第一個小於等於m的時候停下來
          j --
        }
        while (a[i] <= temp && i < j) { //向右移i，直到遇到第一個大於等於m的時候停下來
          i ++
        }
        if (i < j) {
          num ++;
          [a[i],a[j]] = [a[j],a[i]]
          console.log("這是第" + num + "次排序:" + a + "\n");
        }
      }
      // 將基準值歸位
      a[left] = a[i];
      a[i] = temp;
      if (i - 2 > left) quickSort(left, i - 1);
      if (right > i + 2) quickSort(i + 1, right);
    }
    quickSort(0, a.length - 1)

深度優先遍歷

   var deepArr = [];
   function deepTraversal(node) {
      deepArr.push(node);
      var children = node.children;
      for (let i = 0; i < children.length; i ++) {
        // deepArr.push(children[i]);
        deepTraversal(children[i])
      }
    }
    var node = document.getElementById('root');
    deepTraversal(node);
    console.log(deepArr);

廣度優先遍歷

    var wideArr = [];
    function wideTraversal(node) {
      let i = 0;
      if(node) {
        wideArr.push(node);
        node.id !== 'root' && wideTraversal(node.nextElementSibling);
        wideTraversal(node.firstElementChild);
      }
    }
    var node = document.getElementById('root');
    wideTraversal(node);
    console.log(wideArr)