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)