文章直達地址: https://labuladong.gitbook.io/algo/di-ling-zhang-bi-du-xi-lie/xue-xi-shu-ju-jie-gou-he-suan-fa-de-gao-xiao-fang-fa

本系列為labuladong的算法小抄的javascript實現版本，實現原理參考labuladong的算法小抄欠雌。
本文為第0章第1小節(jié)《學習算法和刷題的框架思維》所涉及的代碼，直接上代碼

//二叉樹
/**
 * Definition for a binary tree node.
 **/
function TreeNode(val, left, right) {
  this.val = val === undefined ? 0 : val;
  this.left = left === undefined ? null : left;
  this.right = right === undefined ? null : right;
}

// N叉數
// class TreeNode {
//   constructor(val, children) {
//     this.val = val;
//     this.children = children;
//   }
// }

// 二叉樹遍歷
// function traverse(root) {
//   //   console.log(root.val); // 前序
//   if (root.left) traverse(root.left);
//   console.log(root.val); // 中序

//   if (root.right) traverse(root.right);
//   //   console.log(root.num); // 后序
// }

// function traverse(root) {
//   console.log(root.val);
//   if (root.children == null || root.children.length == 0) return;
//   for (let i = 0; i < root.children.length; i++) {
//     traverse(root.children[i]);
//   }
// }

// let left = new TreeNode(2);
// let right = new TreeNode(3);
// let root = new TreeNode(1, left, right);
// traverse(root);

// let child1 = new TreeNode(2, null);
// let child2 = new TreeNode(3, null);
// let root = new TreeNode(1, [child1, child2]);
// traverse(root);

// 求二叉樹中最大路徑和

/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxPathSum = function (root) {
  let ans = -Infinity;
  var oneSideMax = function (root) {
    if (root === null) return 0;
    let left = Math.max(0, oneSideMax(root.left));
    let right = Math.max(0, oneSideMax(root.right));
    ans = Math.max(ans, left + right + root.val);
    return Math.max(left, right) + root.val;
  };
  oneSideMax(root);
  return ans;
};

// 根據前序遍歷和中序遍歷的結果還原一棵二叉樹
var buildTree = function (preorder, inorder) {
  return recover(
    preorder,
    0,
    preorder.length - 1,
    inorder,
    0,
    inorder.length - 1
  );
};

var recover = function (preArray, preStart, preEnd, inArray, inStart, inEnd) {
  if (preStart > preEnd || inStart > inEnd) return null;
  let root = new TreeNode(preArray[preStart]);
  let inRoot = inArray.indexOf(root.val);
  let leftNum = inRoot - inStart;
  root.left = recover(
    preArray,
    preStart + 1,
    preStart + leftNum,
    inArray,
    inStart,
    inRoot - 1
  );
  root.right = recover(
    preArray,
    preStart + leftNum + 1,
    preEnd,
    inArray,
    inRoot + 1,
    inEnd
  );
  return root;
};

//恢復二叉搜索樹

/**
 * @param {TreeNode} root
 * @return {void} Do not return anything, modify root in-place instead.
 */

var recoverTree = function (root) {
  let prev = null;
  let first = null;
  let second = null;
  const traverse = function (root) {
    if (!root) return;
    traverse(root.left);

    if (prev && root.val < prev.val) {
      second = second == null ? prev : second;
      first = root;
    }
    prev = root;
    traverse(root.right);
  };
  traverse(root);
  let temp = first.val;
  first.val = second.val;
  second.val = temp;
};