leetcode 樹 相關

二叉樹的前序遍歷

一、遞歸方式

func preorderTraversal(root *TreeNode) []int {
	result := make([]int, 0)
	preorder(root, &result)
	return result
}
func preorder(root *TreeNode, result *[]int) {
	if root == nil {
		return
	}

	*result = append(*result, root.Val)
	preorder(root.Left, result)
	preorder(root.Right, result)
}
複製代碼

二叉樹的中序遍歷

一、遞歸方式

func inorderTraversal(root *TreeNode) []int {
	result := make([]int, 0)
	inorder(root, &result)
	return result
}
func inorder(root *TreeNode, result *[]int) {
	if root == nil {
		return
	}
	inorder(root.Left, result)
	*result = append(*result, root.Val)
	inorder(root.Right, result)
}
複製代碼

二叉樹的後序遍歷

一、遞歸方式

func postorderTraversal(root *TreeNode) []int {
	result := make([]int, 0)
	postorder(root, &result)
	return result
}
func postorder(root *TreeNode, result *[]int) {
	if root == nil {
		return
	}

	postorder(root.Left, result)
	postorder(root.Right, result)
	*result = append(*result, root.Val)
}
複製代碼

二叉樹的層次遍歷

一、使用隊列，BFS

func levelOrder(root *TreeNode) [][]int {
	result := make([][]int, 0)
	if root == nil {
		return result
	}
	queue := make([]*TreeNode, 0)
	queue = append(queue, root)
	for len(queue) > 0 {
		level := make([]int, 0)
		queueSize := len(queue)
		for i := 0; i < queueSize; i++ {
			root := queue[0]
			queue = queue[1:]
			val := root.Val
			level = append(level, val)
			if root.Left != nil {
				queue = append(queue, root.Left)
			}
			if root.Right != nil {
				queue = append(queue, root.Right)
			}
		}
		result = append(result, level)
	}
	return result
}
複製代碼

相同的樹

正常遞歸判斷就行

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSameTree(p *TreeNode, q *TreeNode) bool {
	return sameTree(p, q)
}
func sameTree(p *TreeNode, q *TreeNode) bool {
	if p != nil && q != nil && p.Val != q.Val {
		return false
	}
    if p== nil && q==nil {
		return true
	}
    if p==nil && q!=nil || p!=nil&&q==nil {
		return false
	}
	left := sameTree(p.Left, q.Left)
	right := sameTree(p.Right, q.Right)
	return left && right
}
複製代碼

對稱二叉樹

一種是遞歸方式

func isSymmetric(root *TreeNode) bool {
	if root == nil {
		return true
	}
	return symmetric(root.Left, root.Right)
}
func symmetric(p *TreeNode, q *TreeNode) bool {
	if p != nil && q != nil && p.Val != q.Val {
		return false
	}
	if p == nil && q == nil {
		return true
	}
	if p == nil && q != nil || p != nil && q == nil {
		return false
	}
	left := symmetric(p.Left, q.Right)
	right := symmetric(p.Right, q.Left)
	return left && right
}

複製代碼

一種是利用層次遍歷，層次遍歷是先加左子樹再加右子樹到隊列。這裏能夠先加左子樹的左子樹 再加右子樹的右子樹

func isSymmetric(root *TreeNode) bool {
	if root == nil {
		return true
	}
	queue := make([]*TreeNode, 0)
	queue = append(queue, root)
	queue = append(queue, root)
	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 == nil && right != nil {
			return false
		}
		if left.Val == right.Val {
			queue = append(queue, left.Left)
			queue = append(queue, right.Right)
			queue = append(queue, left.Right)
			queue = append(queue, right.Left)
        } else {
            return false
        }
	}

	return true
}

複製代碼