go算法入门(二叉数的删除操作)

题目：

原二叉树[2 3 5 4 6 7 8]， 删除节点 5

输出[2 3 4  6 7 8]

代码如下：

package main
import "fmt"
// TreeNode 结构体表示二叉树节点
type TreeNode struct{
  Val   int
  Left  *TreeNode
  Right *TreeNode
}
// CreateNode 函数用于创建一个新的节点
func CreateNode(val int) *TreeNode{
  return &TreeNode{Val: val}
}
// InsertNode 函数用于插入一个新节点
func InsertNode(root *TreeNode, node *TreeNode) *TreeNode{
  // 如果根节点为空，则直接返回新的节点
  if root == nil{ 
    return node
  }
  // 如果新节点的值小于根节点的值，则该节点应该被插入根节点的左侧
  if node.Val < root.Val{ 
    root.Left = InsertNode(root.Left, node)
  // 如果新节点的值大于等于根节点的值，则该节点应该被插入根节点的右侧
  }else{ 
    root.Right = InsertNode(root.Right, node)
  }
    return root
}
// DeleteNode 函数用于删除指定值的节点，并返回删除后的新的根节点
func DeleteNode(root *TreeNode, key int) *TreeNode{
  // 如果根节点为空，则直接返回 nil  
  if root == nil{ 
    return nil
  }
  // 如果要删除的值小于根节点的值，则该节点应该被删除在根节点的左侧
  if key < root.Val{ 
    root.Left = DeleteNode(root.Left, key)
  // 如果要删除的值大于根节点的值，则该节点应该被删除在根节点的右侧
  }else if key > root.Val{ 
    root.Right = DeleteNode(root.Right, key)
  // 如果要删除的值等于根节点的值，则该节点为要被删除的节点
  }else{
	  // 如果被删除的节点没有子节点，则直接返回 nil
    if root.Left == nil && root.Right == nil{ 
      return nil
	  // 如果被删除的节点只有右子节点，则返回该右子节点
    }else if root.Left == nil{ 
      return root.Right
	  // 如果被删除的节点只有左子节点，则返回该左子节点
    }else if root.Right == nil{ 
      return root.Left
	  // 如果被删除的节点既有左子节点又有右子节点，则找到其左子树中的最大节点，使其成为新的根节点
    }else{ 
	  // 找到左子树中的最大节点
      maxLeft := findMaxNode(root.Left) 
	  // 将该节点的值替换为最大节点的值
      root.Val = maxLeft.Val  
	  // 删除原最大节点          
      root.Left = DeleteNode(root.Left, maxLeft.Val) 
    }
  }
  return root
}
// findMaxNode 函数用于查找节点的左子树中的最大节点
func findMaxNode(node *TreeNode) *TreeNode{
  // 如果有右子节点，则继续向右子树查找
  for node.Right != nil{ 
    node = node.Right
  }
  return node
}
// inorderTraversal 函数用于中序遍历二叉树，并返回节点值的数组
func inorderTraversal(root *TreeNode, vals []int) []int{
  // 如果根节点为空，则返回数组  
  if root == nil{ 
    return vals
  }
  // 先遍历左子树
  vals = inorderTraversal(root.Left, vals) 
  // 将根节点的值加入到数组中
  vals = append(vals, root.Val)   
  // 最后遍历右子树         
  vals = inorderTraversal(root.Right, vals) 
  return vals
}
func main() {
  // 创建二叉树
  root := CreateNode(5)
  InsertNode(root, CreateNode(3))
  InsertNode(root, CreateNode(2))
  InsertNode(root, CreateNode(4))
  InsertNode(root, CreateNode(7))
  InsertNode(root, CreateNode(6))
  InsertNode(root, CreateNode(8))
  // 删除节点
  key := 5
  root = DeleteNode(root, key)
  // 中序遍历，验证是否删除成功
  fmt.Println(inorderTraversal(root, []int{})) 
}

结果如下：

[2 3 4 6 7 8]