程式碼隨想錄演算法訓練營第十五天|leetcode110. 平衡二叉樹、leetcode257.二叉樹的所有路徑、leeetcode404.左葉子之和、leetcode222.完全二叉樹的節點個數

小方呀0524發表於2024-11-03
演算法LeetCode二叉樹

1 leetcode110. 平衡二叉樹

題目連結：110. 平衡二叉樹 - 力扣（LeetCode）

文章連結：程式碼隨想錄

影片連結：後序遍歷求高度，高度判斷是否平衡 | LeetCode：110.平衡二叉樹_嗶哩嗶哩_bilibili

1.1 影片看後的思路

1.1.1完整的程式碼

就是不斷判斷，對其資料儲存，其實突然發現每道題思路真的都很像，就是聽了覺得很簡單，選擇的方式是前序遍歷的方法

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        if self.height(root) == -1:
            return False
        else:
            return True
    def height(self,node):
        if node == None:
            return 0
        left_height = self.height(node.left)
        if left_height == -1:
            return -1
        right_height = self.height(node.right)
        if right_height == -1:
            return -1
        if abs(left_height-right_height) >1:
            return -1
        else :
            return 1+max(left_height,right_height)
1.1.2 精簡的程式碼

這個就是把if合成一句話了，當時邊寫的過程就想到了

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        if self.height(root) == -1:
            return False
        else:
            return True
    def height(self,node):
        if node == None:
            return 0
        left_height = self.height(node.left)
        right_height = self.height(node.right)
        if left_height==-1 or right_height==-1 or abs(left_height-right_height) >1:
            return -1
        return 1+max(left_height,right_height)

1.2 小結

  1. 什麼是平衡二叉樹？就是左右子樹相差的值小於等於1，才能叫平衡，就是根據這個思路對其進行迭代，進行寫的
  2. 其他的地方好像沒有需要注意的點了

2 leetcode257.二叉樹的所有路徑

題目連結：257. 二叉樹的所有路徑 - 力扣（LeetCode）

文章連結：程式碼隨想錄

影片連結：遞迴中帶著回溯，你感受到了沒？| LeetCode：257. 二叉樹的所有路徑_嗶哩嗶哩_bilibili

思考的思路：首先這道題用前序遍歷，然後想著儲存遍歷的值，如果遇到none的時候，就想上返回；emmmm,寫到這裡的時候發現可以用棧對資料進行儲存，然後如果遇到none彈出，繼續去遍歷另一邊，不過自己寫的話不知道怎麼寫

2.1 影片後的思路

其實我覺得思路上沒有問題，就是不知道如何儲存值，但是看了影片講解以後，就覺得自己好像多用一個函式之類的就吃虧了，，，。但是整體思路確實現在可以想出來了

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        result = []
        path = []
        if root == None:
            return result
        self.traversal(root,path,result)
        return result
    def traversal(self,node,path,result):
        path.append(node.val)
        if node.left==None and node.right == None:
            spath = '->'.join(map(str,path))
            result.append(spath)
            return
        if node.left:
            self.traversal(node.left,path,result)
            path.pop()
        if node.right:
            self.traversal(node.right,path,result)
            path.pop()

2.2 本題小結

  1. 主要是遞迴和回溯，但是寫完以後發現，就是取了一個高大上的名字，也很普通，，，
  2. 嗯，在這裡恭喜一下自己吧，思路越來越明瞭，雖然程式碼需要模仿，但是我是越來越有思路了，不再害怕遞迴之類的了

3 leeetcode404.左葉子之和

題目連結：404. 左葉子之和 - 力扣（LeetCode）

文章連結：程式碼隨想錄

影片連結：二叉樹的題目中，總有一些規則讓你找不到北 | LeetCode：404.左葉子之和_嗶哩嗶哩_bilibili

思考的思路：使用前序遍歷，然後就是如果遇到左子樹且左子樹的左子樹和左子樹的右子樹沒有值，就將這個值儲存，然後數進行返回

3.1 影片後的思路

首先我之前的想法前序遍歷，但是前序遍歷的話存在問題就是最後的最後值儲存在哪裡呢？好像沒地方可以儲存了，所以就需要使用後序遍歷，遍歷過程最後將值儲存起來

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0
        if root.left ==None and root.right == None:
            return 0
        left_value = self.sumOfLeftLeaves(root.left)
        if root.left and not root.left.left and not root.left.right:
            left_value = root.left.val
        right_value = self.sumOfLeftLeaves(root.right)
        num = left_value + right_value
        return num

3.2 本題小結

  1. 就是後序遍歷的一個方法吧，感覺做了很多，但是目前掌握的還是很一般，會不明白為什麼

4 leetcode222.完全二叉樹的節點個數

題目連結：222. 完全二叉樹的節點個數 - 力扣（LeetCode）

文章連結：程式碼隨想錄

影片連結：要理解普通二叉樹和完全二叉樹的區別！ | LeetCode：222.完全二叉樹節點的數量_嗶哩嗶哩_bilibili

思路：就是計算左右節點的個數，然後再加上最上面的1即可進行

4.1 影片後的思路

4.1.1 二叉樹的思路

跟之前求深度一樣，只是這次將兩邊都進行了相加的工作

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        return self.depth(root)

    def depth(self,node):
        if node ==None:
            return 0
        depth_left = self.depth(node.left)
        depth_right = self.depth(node.right)
        tree_node = 1+depth_left+depth_right
        return tree_node
4.1.2 滿二叉樹的思路

這裡面有一個位運算，其實有點沒想到

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0
        left = root.left
        right = root.right
        left_depth,right_depth = 0,0
        while left:
            left = left.left
            left_depth +=1
        while right:
            right = right.right
            right_depth +=1
        if left_depth==right_depth:
            return (2<<left_depth)-1
        left_tree = self.countNodes(root.left)
        right_tree = self.countNodes(root.right)
        result = left_tree+right_tree+1
        return result

4.2 本題小結

  1. 可以使用普通二叉樹中的迭代，但是也可以使用完全二叉樹增加判斷

5 今日小結

  1. 其實這幾道題主要就是對二叉樹遍歷方式選擇的一個掌握
  2. 對遞迴法的理解更加深刻了
  3. 在第二問的時候接觸了回溯的演算法，就是需要儲存的一個方式

相關文章