Python算法题

二叉树前序遍历

# 构造如下二叉树
#      1
#     / \
#    2   3
#   / \
#  4   5
class TreeNode:
    def __init__(self,val=0,left = None,right = None):
        self.val = val
        self.left = left
        self.right = right

def preorderTravel(root):
    ans = []
    def preorder(node):
        if not node:
            return
        ans.append(node.val)
        preorder(node.left)
        preorder(node.right)
    preorder(root)
    return ans

node4 = TreeNode(4)
node5 = TreeNode(5)
node3 = TreeNode(3)
node2 = TreeNode(2,node4,node5)
root = TreeNode(1,node2,node3)
ans = preorderTravel(root)
print(ans)

二叉树后序遍历

# 构造如下二叉树
#      1
#     / \
#    2   3
#   / \
#  4   5
class TreeNode:
    def __init__(self,val=0,left = None,right = None):
        self.val = val
        self.left = left
        self.right = right

def afterorderTravel(root):
    ans = []
    def afterorder(node):
        if not node:
            return
        afterorder(node.left)
        afterorder(node.right)
        ans.append(node.val)
    afterorder(root)
    return ans

node4 = TreeNode(4)
node5 = TreeNode(5)
node3 = TreeNode(3)
node2 = TreeNode(2,node4,node5)
root = TreeNode(1,node2,node3)
ans = afterorderTravel(root)
print(ans)

二叉树层序遍历

# 构造如下二叉树
#      1
#     / \
#    2   3
#   / \
#  4   5

class TreeNode:
    def __init__(self,val = 0,left =None,right = None):
        self.val = val
        self.left = left
        self.right = right

def LevelOrderTraevl(root):
    res = []
    min_depth = 0
    def level_order(node,depth):
        if not node:
            return 0
        if len(res) == depth:
            res.append([])
        res[depth].append(node.val)
        level_order(node.left,depth+1)
        level_order(node.right,depth+1)
    level_order(root,0)
    return  len(res)

node5 = TreeNode(5)
node4 = TreeNode(4)
node3 = TreeNode(3)
node2 = TreeNode(2,node4,node5)
root = TreeNode(1,node2,node3)
ans = LevelOrderTraevl(root)
print(ans)

二叉树最大、最小深度

# 二叉树-二叉树的最大深度
# 题目: 给定一个二叉树，找出其最大深度。最大深度是从根节点到最远叶子节点的最长路径上的节点数。
# 定义二叉树节点类
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# 计算二叉树的最小深度
def minDepth(root):
    """
    递归法，返回二叉树的最大深度
    :param root: TreeNode，二叉树的根节点
    :return: int，最大深度
    """
    if not root:
        return 0
    left_depth = minDepth(root.left)
    right_depth = minDepth(root.right)
    if left_depth ==0 or right_depth==0:
        return max(left_depth,right_depth)+1
    return min(left_depth, right_depth) + 1

# 计算二叉树的最大深度
def maxDepth(root):
    """
    递归法，返回二叉树的最大深度
    :param root: TreeNode，二叉树的根节点
    :return: int，最大深度
    """
    if not root:
        return 0
    left_depth = maxDepth(root.left)
    right_depth = maxDepth(root.right)
    return max(left_depth, right_depth) + 1

# 测试代码
if __name__ == "__main__":
    # 构造如下二叉树
    #      1
    #     / \
    #    2   3
    #   / \
    #  4   5
    node4 = TreeNode(4)
    node5 = TreeNode(5)
    node2 = TreeNode(2, node4, node5)
    node3 = TreeNode(3)
    root = TreeNode(1, node2, node3)

    print("二叉树的最大深度为：", maxDepth(root))
    print("二叉树的最小深度为：", minDepth(root))

层序构建二叉树

class TreeNode:
    def __init__(self,val,left = None,right = None):
        self.val = val
        self.left = left
        self.right = right


from collections import deque

def array_to_bst(arr):
    if not arr:
        return None
    root = TreeNode(arr[0])
    queue = deque([root])
    i = 1
    while i < len(arr):
        node = queue.popleft()
        if i < len(arr):
            node.left = TreeNode(arr[i])
            queue.append(node.left)
            i += 1
        if i < len(arr):
            node.right = TreeNode(arr[i])
            queue.append(node.right)
            i += 1
    return root

arr = [1, 2, 3, 4, 5, 6, 7]
root = array_to_bst(arr)