1.对称二叉树
思路:
- 递归法,从根节点开始,向两边扩散,遍历的顺序是相反的
- 迭代法,可以层次遍历,
1.1 递归法
func isSymmetric(root *TreeNode) bool {
if root==nil{
return true
}
return compare(root.Left,root.Right)
}
func compare(node1 *TreeNode,node2 *TreeNode) bool{
if node1==nil && node2==nil{
return true
}
if node1==nil || node2==nil{
return false
}
if node1.Val!=node2.Val{
return false
}
inside := compare(node1.Right,node2.Left)
outside := compare(node1.Left,node2.Right)
return inside && outside
}
1.2 迭代法
func isSymmetric(root *TreeNode) bool {
if root==nil{
return true
}
var queue []*TreeNode
queue = append(queue,root.Left,root.Right)
for len(queue)>0{
left := queue[0]
right := queue[1]
queue = queue[2:]
if left==nil && right==nil {
continue
}
if left==nil || right==nil || (left.Val!=right.Val){
return false
}
queue = append(queue,left.Right,right.Left,left.Left,right.Right)
}
return true
}
1.3 相同的树
采用递归的方法较为简单:
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func isSameTree(p *TreeNode, q *TreeNode) bool {
return isSame(p,q)
}
func isSame(node1 *TreeNode,node2 *TreeNode) bool {
if node1==nil && node2==nil{
return true
}
if node1==nil || node2==nil || node1.Val!=node2.Val{
return false
}
return isSame(node1.Left,node2.Left) && isSame(node1.Right,node2.Right)
}
1.4 另一棵树的子树
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func isSubtree(root *TreeNode, subRoot *TreeNode) bool {
if root==nil{
return false
}
if isSameTree(root, subRoot) {
return true
}
return isSubtree(root.Left, subRoot) || isSubtree(root.Right,subRoot)
}
func isSameTree(s,t *TreeNode)bool{
if s==nil && t==nil{
return true
}
if s==nil || t==nil {
return false
}
return s.Val==t.Val && isSameTree(s.Left,t.Left) && isSameTree(s.Right,t.Right)
}
2.二叉树的最大深度
2.1 层次遍历
func maxDepth(root *TreeNode) int {
ans := 0
if root == nil{
return 0
}
queue := list.New()
queue.PushBack(root)
for queue.Len() > 0 {
length := queue.Len()
for i := 0; i < length; i++ {
node := queue.Remove(queue.Front()).(*TreeNode)
if node.Left != nil {
queue.PushBack(node.Left)
}
if node.Right != nil {
queue.PushBack(node.Right)
}
}
ans++//记录深度,其他的是层序遍历的板子
}
return ans
}
2.2 递归法
func maxDepth(root *TreeNode) int {
if root==nil{
return 0
}
return 1+maxNum(maxDepth(root.Left),maxDepth(root.Right))
}
func maxNum(a,b int) int {
if a>b{
return a
}
return b
}
2.3 N叉树的最大深度
只能使用层次遍历法。
func maxDepth(root *Node) int {
if root == nil {
return 0
}
var queue []*Node
queue = append(queue,root.Children...)
ans := 1
for len(queue)>0{
ans++
length := len(queue)
for i:=0;i<length;i++{
queue = append(queue,queue[i].Children...)
}
queue = queue[length:]
}
return ans
}
3.二叉树的最小深度
3.1 层次遍历
func minDepth(root *TreeNode) int {
li := make([]*TreeNode, 0)
tmp := make([]*TreeNode, 0)
ans := 0
if root == nil {
return ans
}
li = append(li, root)
for len(li) > 0 {
length := len(li)
ans++
for i := 0; i < length; i++ {
if li[i].Left == nil && li[i].Right == nil {
return ans
}
if li[i].Left != nil {
tmp = append(tmp, li[i].Left)
}
if li[i].Right != nil {
tmp = append(tmp, li[i].Right)
}
}
li = tmp
tmp = nil
}
return ans
}
3.2 递归算法
func minDepth(root *TreeNode) int {
if root==nil{
return 0
}
if root.Left==nil && root.Right!=nil{
return 1+minDepth(root.Right)
}
if root.Left!=nil && root.Right==nil{
return 1+minDepth(root.Left)
}
return 1+minNum(minDepth(root.Left),minDepth(root.Right))
}
func minNum(a,b int) int{
if a<b{
return a
}
return b
}
4.完全二叉树的节点个数
4.1 层次遍历法
func countNodes(root *TreeNode) int {
ans := 0
if root == nil {
return ans
}
var arr []*TreeNode
arr = append(arr,root)
ans++
for len(arr)>0{
length := len(arr)
for index:=length-1;index>=0;index--{
if arr[index].Left!=nil{
ans++
arr = append(arr,arr[index].Left)
}
if arr[index].Right!=nil{
ans++
arr = append(arr,arr[index].Right)
}
}
arr = arr[length:]
}
return ans
}
4.2 递归版本
//本题直接就是求有多少个节点,无脑存进结果变量就行了。
func countNodes(root *TreeNode) int {
if root == nil {
return 0
}
res := 1
if root.Right != nil {
res += countNodes(root.Right)
}
if root.Left != nil {
res += countNodes(root.Left)
}
return res
}
5.平衡二叉树
5.1递归
在计算各个节点高度的同时判断是否是是否是平衡树。
func isBalanced(root *TreeNode) bool {
h := getHeight(root)
if h == -1 {
return false
}
return true
}
func getHeight(root *TreeNode)int{
if root==nil{
return 0
}
l, r := getHeight(root.Left), getHeight(root.Right)
if l==-1 || r==-1{
return -1
}
if l - r > 1 || r - l > 1 {
return -1
}
return max(l, r) + 1
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
6.二叉树的所有路径
6.1 递归法
递归终止的条件是:左右两个子节点都为空的时候,则记录这一条路径。
func binaryTreePaths(root *TreeNode) []string {
ans := make([]string, 0)
if root == nil {
return ans
}
findPath(root, "", &ans)
return ans
}
func findPath(node *TreeNode, temp string, ans *[]string) {
if node.Left == nil && node.Right == nil {
temp = temp + strconv.Itoa(node.Val)
*ans = append(*ans, temp)
}
temp = temp + strconv.Itoa(node.Val)+ "->"
if node.Left != nil {
findPath(node.Left, temp, ans)
}
if node.Right != nil {
findPath(node.Right, temp, ans)
}
}