本文详细介绍了二叉树的各种操作，包括平衡二叉树的判定、插入节点到二叉搜索树、利用前序与中序遍历构建二叉树、通过中序与后序遍历构建二叉树以及在二叉搜索树中移除节点等核心算法。
Balanced Binary Tree
Given a binary tree, determine if it is height-balanced.
For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
Given binary tree A = {3,9,20,#,#,15,7}, B = {3,#,20,15,7}
A) 3 B) 3
/ \ \
9 20 20
/ \ / \
15 7 15 7
The binary tree A is a height-balanced binary tree, but B is not.
如果左右subtree都是平衡的，但是要符合两边高度差不能大于1
/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution {
/**
* @param root: The root of binary tree.
* @return: True if this Binary tree is Balanced, or false.
*/
public boolean isBalanced(TreeNode root) {
return helper(root)!=-1;
}
private int helper(TreeNode root){
if(root==null){
return 0;
}
int leftDepth=helper(root.left);
int rightDepth=helper(root.right);
if(leftDepth==-1 || rightDepth==-1 || Math.abs(leftDepth-rightDepth)>1){
return -1;
}
return Math.max(leftDepth,rightDepth)+1;
}
}Insert Node in a Binary Search Tree
Given a binary search tree and a new tree node, insert the node into the tree. You should keep the tree still be a valid binary search tree.
You can assume there is no duplicate values in this tree + node.
Given binary search tree as follow, after Insert node 6, the tree should be:
2 2
/ \ / \
1 4 --> 1 4
/ / \
3 3 6
如果node的值比当前root值小，去向就是左边，继续找，如果左边值不为null，继续判断，如果为null，就直接赋值node为这个位置
如果node的值比当前root值大，去向就是右边，继续找，如果右边值不为null，继续判断，如果为null，就直接赋值node为这个位置
/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution { //non-recursion
/**
* @param root: The root of the binary search tree.
* @param node: insert this node into the binary search tree
* @return: The root of the new binary search tree.
*/
public TreeNode insertNode(TreeNode root, TreeNode node) {
if(root==null){
return node;
}
TreeNode cur=root;
while(true){ //因为while(true)是一个无限循环，表达式一直为真
if(node.val<cur.val){ //需要break跳出循环
if(cur.left!=null){
cur=cur.left;
}else{
cur.left=node;
break;
}
}else if(node.val>cur.val){
if(cur.right!=null){
cur=cur.right;
}else{
cur.right=node;
break;
}
}
}
return root;
}
}/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution { //recursion
/**
* @param root: The root of the binary search tree.
* @param node: insert this node into the binary search tree
* @return: The root of the new binary search tree.
*/
public TreeNode insertNode(TreeNode root, TreeNode node) {
if(root==null){
return node; //这里写成root=node是一样的
}
if(node.val<root.val){
root.left=insertNode(root.left, node);
}else{ //因为题目指出没有duplicates，因此else的情况就是
root.right=insertNode(root.right, node); //node.val>root.val
}
return root;
}
}Construct Binary Tree from Preorder and Inorder Traversal
Given preorder and inorder traversal of a tree, construct the binary tree.
You may assume that duplicates do not exist in the tree.
Given in-order [1,2,3] and pre-order [2,1,3], return a tree:
2
/ \
1 3
pos的前面的就是左子树，pos的后面的就是右子树
注意：左右子树递归的时候，找preorder开始和结束位置的边界的时候，长度可以由inorder的长度来计算
例如root.left=build(inoder,istart,pos-1,preorder,pstart+1,end);
end值的计算：根据inorder部分计算左子树占据的数组长度，pos-1-istart+1=pos-istart
因此preorder这部分的长度也是pos-istart，又因为preorder从pstart开始，所以最后知end为pstart+pos-istart
/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution {
/**
*@param preorder : A list of integers that preorder traversal of a tree
*@param inorder : A list of integers that inorder traversal of a tree
*@return : Root of a tree
*/
public TreeNode buildTree(int[] preorder, int[] inorder) {
if(preorder==null || inorder==null){
return null;
}
if(preorder.length!=inorder.length){
return null;
}
return build(inorder,0,inorder.length-1,preorder,0,preorder.length-1);
}
private TreeNode build(int[] inorder,int istart,int iend,int[] preorder,int pstart,int pend){
if(istart>iend){ //这边写成pstart<pend也是一样的
return null;
}
int pos=findPosition(inorder,istart,iend,preorder[pstart]);
TreeNode root=new TreeNode(preorder[pstart]);
root.left=build(inorder,istart,pos-1,preorder,pstart+1,pstart+pos-istart);
root.right=build(inorder,pos+1,iend,preorder,pstart+pos-istart+1,pend); //preorder的右边开始位置是
return root; //preorder左边结束位置+1
}
private int findPosition(int[] arr,int start,int end,int pos){
for(int i=start;i<=end;i++){
if(arr[i]==pos){
return i;
}
}
return -1;
}
}Construct Binary Tree from inorder and postorder traversal
Given inorder and postorder traversal of a tree, construct the binary tree.
You may assume that duplicates do not exist in the tree.
Given inorder [1,2,3] and postorder [1,3,2], return a tree:
2
/ \
1 3
思路：和inorder，preorder建树的思路一样
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode buildTree(int[] inorder, int[] postorder) {
if(inorder.length!=postorder.length){
return null;
}
return build(inorder,0,inorder.length-1,postorder,0,postorder.length-1);
}
public TreeNode build(int[] inorder,int istart,int iend, int[] postorder,int pstart,int pend) {
if(istart>iend){
return null;
}
TreeNode root=new TreeNode(postorder[pend]);
int pos=finPos(inorder,istart,iend,postorder[pend]);
root.left=build(inorder,istart,pos-1,postorder,pstart,pstart+pos-istart-1);
root.right=build(inorder,pos+1,iend,postorder,pstart+pos-istart,pend-1);
return root;
}
private int finPos(int[] arr,int start,int end,int pos){
for(int i=start;i<=end;i++){
if(arr[i]==pos){
return i;
}
}
return -1;
}
}Remove Node in Binary Search Tree
Given a root of Binary Search Tree with unique value for each node. Remove the node with given value. If there is no such a node with given value in the binary search tree, do nothing. You should keep the tree still a binary search tree after removal.
Given binary search tree:
5 / \36 / \ 24当前root下有两个结点，找右面最小值，此时为4，把4赋值到当前root，再对4进行递归，此时value=4，下面没有结点，返回null
Remove 3, you can either return:
5
/ \
2 6
\
4
or
5
/ \
4 6
/
2 本题解法就是最后建立这样一颗树要删除的node下面没有结点，直接把此结点设为null
要删除的node下面只有一个或左或右的结点，或者是说只有左子树或者只有右子树，直接返回这颗树
要删除的node下面有两个结点，找到右子树的最小值结点，根据BST知，最小值结点一定在左面，或者就是它自己，
把找到的最小值赋值到当前node的值，
对于当前node的右子树再进行同样的递归，此时要递归删除的value就是刚才找到的右子树的最小值点
/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution {
/**
* @param root: The root of the binary search tree.
* @param value: Remove the node with given value.
* @return: The root of the binary search tree after removal.
*/
public TreeNode removeNode(TreeNode root, int value) {
if(root==null){
return null;
}
if(value>root.val){
root.right=removeNode(root.right, value);
}else if(value<root.val){
root.left=removeNode(root.left, value);
}else{
if(root.left==null && root.right==null){
return null;
}
if(root.left==null){
return root.right;
}
if(root.right==null){
return root.left;
}
TreeNode minRight=findNode(root.right);
root.val=minRight.val;
root.right=removeNode(root.right,minRight.val); //此时要递归的value就是刚才找到的右子树最小值
}
return root;
}
private TreeNode findNode(TreeNode cur){
while(cur.left!=null){
cur=cur.left;
}
return cur;
}
}
扫一扫
405
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
