//235. 二叉搜索树的最近公共祖先
package main
import "fmt"
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
//利用二叉搜素树的特性,从上往下搜索,如果结点的值在p和q之间,则该节点为所求结点
//终止条件
if root == nil {
return nil
}
//左
if root.Val > p.Val && root.Val > q.Val {
left := lowestCommonAncestor(root.Left, p, q)
if left != nil {
return left
}
}
//右
if root.Val < p.Val && root.Val < q.Val {
right := lowestCommonAncestor(root.Right, p, q)
if right != nil {
return right
}
}
return root
}
func main() {
//k=3
node1, node2, node3, node4 := TreeNode{3, nil, nil}, TreeNode{8, nil, nil}, TreeNode{11, nil, nil}, TreeNode{13, nil, nil}
//k=2
node5, node6 := TreeNode{5, &node1, &node2}, TreeNode{12, &node3, &node4}
//k=1
node7 := TreeNode{10, &node5, &node6}
res := lowestCommonAncestor(&node7, &node1, &node2)
fmt.Printf("res.val: %v\n", res.Val)
}
//701.二叉搜索树中的插入操作
package main
import "fmt"
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func insertIntoBST(root *TreeNode, val int) *TreeNode {
// 终止条件:遍历到叶子结点,插入结点
if root == nil {
node := &TreeNode{Val: val}
return node
}
if root.Val > val {
root.Left = insertIntoBST(root.Left, val) //注意这里的两个root.Left
} else {
root.Right = insertIntoBST(root.Right, val)
}
return root
}
func main() {
//k=3
node1, node2 := TreeNode{1, nil, nil}, TreeNode{3, nil, nil}
//k=2
node5, node6 := TreeNode{2, &node1, &node2}, TreeNode{15, nil, nil}
//k=1
node7 := TreeNode{5, &node5, &node6}
res := insertIntoBST(&node7, 4)
fmt.Printf("res: %v\n", res)//res: &{5 0xc0000080a8 0xc0000080c0}
}
//450.删除二叉搜索树中的节点
package main
import "fmt"
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func deleteNode(root *TreeNode, key int) *TreeNode {
// 终止条件:5种情况
// 1:未找到目标结点
if root == nil {
return nil
}
print(root.Val)
if root.Val == key {
if root.Left == nil && root.Right == nil { // 2:目标结点左为nil右为nil(删除的点为叶子结点)
return nil
} else if root.Left != nil && root.Right == nil { // 3:目标结点左不为nil右为nil
return root.Left
} else if root.Left == nil && root.Right != nil { // 4:目标结点左为nil右不为nil
return root.Right
} else { // 5:目标结点左不为nil右不为nil
cur := root.Right
for cur.Left != nil {
cur = cur.Left
}
cur.Left = root.Left
return root.Right
}
}
// 单层递归逻辑
if root.Val > key {
root.Left = deleteNode(root.Left, key)
} else {
root.Right = deleteNode(root.Right, key)
}
return root
}
func main() {
//k=3
node1, node2, node3 := TreeNode{2, nil, nil}, TreeNode{4, nil, nil}, TreeNode{7, nil, nil}
//k=2
node4, node5 := TreeNode{3, &node1, &node2}, TreeNode{6, nil, &node3}
//k=1
node6 := TreeNode{5, &node4, &node5}
res := deleteNode(&node6, 3)
fmt.Printf("res: %v\n", res)
}