代码随想录算法训练营day17| 110.平衡二叉树

110.平衡二叉树

深搜递归

递归计算两个子节点的高度差即可

时间复杂度 O(n)           空间复杂度O(1)

func findMax(left int, right int) int {
	if left >= right {
		return left
	} else {
		return right
	}
}

func isBalanced(root *TreeNode) bool {
	var checkTree func(root *TreeNode, depth int) int
	isValid := true
	checkTree = func(root *TreeNode, depth int) int {
		if root == nil {
			return depth
		}
		if root.Left == nil && root.Right == nil {
			return depth + 1
		}
		leftDepth := checkTree(root.Left, depth+1)
		rightDepth := checkTree(root.Right, depth+1)
		if math.Abs(float64(leftDepth-rightDepth)) > 1 {
			isValid = false
		}
		maxDepth := findMax(leftDepth, rightDepth)
		return maxDepth
	}
	checkTree(root, 0)
	return isValid
}

257.二叉树的所有路径

使用栈和深搜

先序遍历，使用栈来表示目前的路径

时间复杂度O(n)               空间复杂度O(n)

type Stack struct {
	stack []int
}

func (s *Stack) Size() int {
	return len(s.stack)
}
func (s *Stack) Push(v int) {
	s.stack = append(s.stack, v)
}
func (s *Stack) Pop() int {
	element := s.stack[s.Size()-1]
	s.stack = s.stack[:s.Size()-1]
	return element
}
func (s *Stack) Empty() bool {
	return s.Size() == 0
}
func (s *Stack) convStr() string {
	if s.Empty(){
		return ""
	}
	str := strconv.Itoa(s.stack[0])		
	for _, v := range s.stack[1:] {
		str = str + "->" + strconv.Itoa(v)	
	}
	return str
}
func binaryTreePaths(root *TreeNode) []string {
	// 先序遍历
	stack := &Stack{}
	result := make([]string, 0)
	var dfs func(root *TreeNode)
	dfs = func(root *TreeNode) {
		if root == nil {
			return
		}
		stack.Push(root.Val)
		if root.Left == nil && root.Right == nil {
			result = append(result, stack.convStr())
			stack.Pop()
			return
		}
		dfs(root.Left)
		dfs(root.Right)
        stack.Pop()
	}
	dfs(root)
	return result
}

404.左叶子之和

时间复杂度O(n)     空间复杂度O(n)

func sumOfLeftLeaves(root *TreeNode) int {
	// 递归遍历所有节点，然后将左叶子节点求和
	sum := 0
	var dfs func(root *TreeNode, isLeft bool) 
	dfs = func(root *TreeNode, isLeft bool)  {
		if root == nil {
			return 
		}
		if root.Left == nil && root.Right == nil {
			if isLeft{
				sum += root.Val
			}	
			return	
		}
		if root.Left != nil {
			dfs(root.Left, true)		
		}
		if root.Right != nil {
			dfs(root.Right, false)
		}
	}
	dfs(root, false)
	return sum
}