654. 最大二叉树
/**
* 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)
* }
*/
/**
* @param {number[]} nums
* @return {TreeNode}
*/
// 使用前序遍历来 序列化这个最大二叉树
var constructMaximumBinaryTree = function(nums) {
function DFS (arr, l, r) {
if (l > r) {
return null;
}
// 找到数组的中的最大值
let newArr = arr.slice(l, r + 1);
let maxVal = -1;
let maxIndex = -1;
maxVal = Math.max(...newArr);
maxIndex = arr.indexOf(maxVal);
let root = new TreeNode(maxVal);
root.left = DFS(arr, l, maxIndex - 1);
root.right = DFS(arr, maxIndex + 1, r);
//
return root;
}
const res = DFS(nums, 0, nums.length - 1);
return res;
};
894. 所有可能的满二叉树
/**
* 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)
* }
*/
/**
* @param {number} n
* @return {TreeNode[]}
*/
var allPossibleFBT = function(n) {
const map = new Map();
if (!map.has(n)) {
const ans = [];
if (n == 1) {
ans.push(new TreeNode(0));
} else if (n % 2 == 1) {
for (let i = 1; i < n; i++) {
let j = n - 1 - i;
// 左子树分配i节点
const leftNodes = allPossibleFBT(i);
const rightNodes = allPossibleFBT(j);
leftNodes.forEach((left) => {
rightNodes.forEach((right) => {
const node = new TreeNode(0);
node.left = left;
node.right = right;
ans.push(node);
});
});
}
}
map.set(n, ans);
}
return map.get(n);
};
1008. 前序遍历构造二叉搜索树
/**
* 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)
* }
*/
/**
* @param {number[]} preorder
* @return {TreeNode}
*/
var bstFromPreorder = function(preorder) {
if (!preorder.length) {
return null;
}
const val = preorder.shift();
let root = new TreeNode(val);
// digui
root.left = bstFromPreorder(preorder.filter(item => item < val));
root.right = bstFromPreorder(preorder.filter(item => item > val));
return root;
};
863. 二叉树中所有距离为 K 的结点
/**
* Definition for a binary tree node.
* function TreeNode(val) {
* this.val = val;
* this.left = this.right = null;
* }
*/
/**
* @param {TreeNode} root
* @param {TreeNode} target
* @param {number} k
* @return {number[]}
*/
/*
从target出发，使用DFS，找到深度为k的所有的节点
遍历的方向是有三个的，分别是左右子节点，还有自己的父节点
其实这个题目最重要的是，还要向自己的父节点去遍历
*/
var distanceK = function(root, target, k) {
const map = new Map();
const res = [];
/* map 记录所有节点的父节点 */
function findParents(node) {
if (node.left) {
map.set(node.left.val, node);
findParents(node.left);
}
if (node.right) {
map.set(node.right.val, node);
findParents(node.right);
}
}
findParents(root);
function DFS (node, from, depth, k) {
if (!node) return;
if (depth === k) {
res.push(node.val);
return;
}
// 向左下边递归
if (node.left !== from) {
DFS(node.left, node, depth + 1, k);
}
/* 向右下边递归 */
if (node.right !== from) {
DFS(node.right, node, depth + 1, k);
}
/* 向父元素递归 */
if (map.get(node.val) !== from) {
DFS(map.get(node.val), node, depth + 1, k);
}
}
DFS(target, null, 0, k);
return res;
};
98. 验证二叉搜索树
/**
* 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)
* }
*/
/**
* @param {TreeNode} root
* @return {boolean}
*/
var isValidBST = function(root) {
let pre = -Infinity;
function inorder(node) {
if (node == null) return true;
let left = inorder(node.left);
// zhu
if (node.val <= pre) return false;
pre = node.val;
let right = inorder(node.right);
return left && right;
}
return inorder(root);
};
99. 恢复二叉搜索树
/**
* 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)
* }
*/
/**
* @param {TreeNode} root
* @return {void} Do not return anything, modify root in-place instead.
*/
var recoverTree = function(root) {
let prev = new TreeNode(-Infinity);
let err1 = null, err2 = null;
function inorder(node) {
if (node == null) return;
inorder(node.left);
// 主逻辑
/* 第一对错误，错的点是prev */
if (prev.val >= node.val && err1 == null) {
err1 = prev;
}
/* 第二对错误，错的点是 node，也就是第二个 */
if (prev.val >= node.val && err1 !== null) {
err2 = node;
}
prev = node;
inorder(node.right);
}
inorder(root);
// swap
let temp = err1.val;
err1.val = err2.val;
err2.val = temp;
return root;
};
