235. 二叉搜索树的最近公共祖先 - 力扣(LeetCode)
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
List<List<TreeNode>> paths = new ArrayList<>();
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
getPaths(root,new ArrayList<>(),p,q);
List<TreeNode> pathA = paths.get(0);
List<TreeNode> pathB = paths.get(1);
for(int i=0;i<pathA.size() && i<pathB.size();i++){
if(pathA.get(i) == p || pathA.get(i) == q){
return pathA.get(i);
}
if(pathA.get(i+1) != pathB.get(i+1)){
return pathA.get(i);
}
}
return null;
}
private void getPaths(TreeNode root,List<TreeNode> path, TreeNode p, TreeNode q){
if(root == null){
return;
}
path.add(root);
if(root == p || root == q){
paths.add(new ArrayList<>(path));
}
if(paths.size() == 2){
return;
}
if(root.left != null){
getPaths(root.left,path,p,q);
path.remove(path.size()-1);
}
if(root.right != null){
getPaths(root.right,path,p,q);
path.remove(path.size()-1);
}
}
}
701. 二叉搜索树中的插入操作 - 力扣(LeetCode)
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public TreeNode insertIntoBST(TreeNode root, int val) {
if(root == null){
return new TreeNode(val);
}
TreeNode insertParent = getInsertParent(root,val);
TreeNode cur = new TreeNode(val);
if(insertParent.val>val){
insertParent.left = cur;
}else{
insertParent.right = cur;
}
return root;
}
private TreeNode getInsertParent(TreeNode root, int val){
if(root.val > val){
if(root.left == null){
return root;
}
return getInsertParent(root.left,val);
}
if(root.val < val){
if(root.right == null){
return root;
}
return getInsertParent(root.right,val);
}
//由于题目说不存在重复的数字,因此不会走到这里
return null;
}
}
450. 删除二叉搜索树中的节点 - 力扣(LeetCode)
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public TreeNode deleteNode(TreeNode root, int key) {
if(root == null){
return null;
}
if(root.val == key){
return deleteValNodeTreeNewRoot(root);
}else{
TreeNode delValParentNode = findDeleteParent(root,key);
if(delValParentNode == null){
//不存在待删除的节点
return root;
}
if(delValParentNode.left != null && delValParentNode.left.val == key){
delValParentNode.left = deleteValNodeTreeNewRoot(delValParentNode.left);
}else{
delValParentNode.right = deleteValNodeTreeNewRoot(delValParentNode.right);
}
return root;
}
}
private TreeNode deleteValNodeTreeNewRoot(TreeNode root){
if(root.left == null && root.right == null){
return null;
}else if(root.left == null){
return root.right;
}else if(root.right == null){
return root.left;
}else{
TreeNode newRoot = root.right;
TreeNode cur = newRoot;
while (cur != null && cur.left!= null){
cur = cur.left;
}
cur.left = root.left;
return newRoot;
}
}
private TreeNode findDeleteParent(TreeNode root, int key){
if(root.left == null && root.right == null){
return null;
}
if(root.val > key && root.left != null){
if(root.left.val==key){
return root;
}
return findDeleteParent(root.left,key);
}
if(root.val < key && root.right != null){
if(root.right.val==key){
return root;
}
return findDeleteParent(root.right,key);
}
return null;
}
}