class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> ans = new ArrayList<>();
inorder(root, ans);
return ans;
}
public void inorder(TreeNode root, List<Integer> ans) {
if ( root == null )
return;
inorder(root.left, ans);
ans.add(root.val);
inorder(root.right, ans);
}
}
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> ans = new ArrayList<>();
preorder(root, ans);
return ans;
}
public void preorder(TreeNode root, List<Integer> ans) {
if ( root == null )
return;
ans.add(root.val);
preorder(root.left, ans);
preorder(root.right, ans);
}
}
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> ans = new ArrayList<>();
postorder(root, ans);
return ans;
}
public void postorder(TreeNode root, List<Integer> ans) {
if ( root == null )
return;
postorder(root.left, ans);
postorder(root.right, ans);
ans.add(root.val);
}
}
class Solution {
// 通过哈希表把中序遍历序列中的值和顺序建立映射关系
private Map<Integer, Integer> indexMap;
public TreeNode buildTree(int[] preorder, int[] inorder) {
int n = inorder.length;
// 构造哈希映射,以中序序列中的元素值 inorder[i] 作为 key,以位置 i 作为 value,存放到哈希表中
indexMap = new HashMap<Integer, Integer>();
for (int i=0; i<n; i++) {
indexMap.put(inorder[i],i);
}
return help(preorder, inorder, 0, n-1, 0, n-1);
}
public TreeNode help(int[] preorder, int[] inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
if (preorder_left > preorder_right)
return null;
// 前序遍历中的第一个节点就是根节点
int preorder_root = preorder_left;
// 在中序遍历中定位根节点
int inorder_root = indexMap.get(preorder[preorder_root]);
// 构建根节点
TreeNode root = new TreeNode(preorder[preorder_root]);
// 左子树中的节点数目
int size_left_subtree = inorder_root - inorder_left;
// 递归地构造左子树,并连接到根节点
// 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
root.left = help(preorder, inorder, preorder_left+1, preorder_left+size_left_subtree, inorder_left, inorder_root-1);
// 递归地构造右子树,并连接到根节点
// 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
root.right = help(preorder, inorder, preorder_left+size_left_subtree+1, preorder_right, inorder_root+1, inorder_right);
return root;
}
}
class Solution {
// 通过哈希表把中序遍历序列中的值和顺序建立映射关系
private Map<Integer, Integer> indexMap;
public TreeNode buildTree(int[] inorder, int[] postorder) {
int n = inorder.length;
// 构造哈希映射,以中序序列中的元素值 inorder[i] 作为 key,以位置 i 作为 value,存放到哈希表中
indexMap = new HashMap<Integer, Integer>();
for (int i=0; i<n; i++) {
indexMap.put(inorder[i],i);
}
return help(inorder, postorder, 0, n-1, 0, n-1);
}
public TreeNode help(int[] inorder, int[] postorder, int inorder_left, int inorder_right, int postorder_left, int postorder_right) {
if (inorder_left > inorder_right)
return null;
// 后序遍历中的最后一个节点就是根节点
int postorder_root = postorder_right;
// 在中序遍历中定位根节点
int inorder_root = indexMap.get(postorder[postorder_root]);
// 构建根节点
TreeNode root = new TreeNode(postorder[postorder_root]);
// 左子树中的节点数目
int size_left_subtree = inorder_root - inorder_left;
// 递归地构造左子树,并连接到根节点
root.left = help(inorder, postorder, inorder_left,inorder_root-1, postorder_left, postorder_left+size_left_subtree-1);
// 递归地构造右子树,并连接到根节点
root.right = help(inorder, postorder, inorder_root+1, inorder_right, postorder_left+size_left_subtree, postorder_right-1);
return root;
}
}
class Solution {
public TreeNode searchBST(TreeNode root, int val) {
if (root == null)
return null;
if (root.val == val)
return root;
else if ( root.val < val )
return searchBST(root.right, val);
else
return searchBST(root.left, val);
}
}
class Solution {
public TreeNode insertIntoBST(TreeNode root, int val) {
if (root == null)
return new TreeNode(val);
if(val < root.val)
root.left = insertIntoBST(root.left, val);
else
root.right = insertIntoBST(root.right, val);
return root;
}
}
class Solution {
public boolean isValidBST(TreeNode root) {
return check(root, Long.MIN_VALUE, Long.MAX_VALUE);
}
public boolean check(TreeNode root, long rangeLeft, long rangeRight) {
if (root == null)
return true;
if (root.val<=rangeLeft || root.val>=rangeRight)
return false;
return check(root.left, rangeLeft, root.val) && check(root.right, root.val, rangeRight);
}
}