【代码随想录】【二叉树】补day15：二叉树层序遍历，翻转二叉树、对称二叉树

层序遍历以及衍生

def levelorderTravelsal(self, root: TreeNode) -> List[List[int]]: #
    if root is not None:
        que=deque()
        result=[]
        que.append(root)
        while len(que)>0: # 不为空 直接pop，但是要记录pop几个元素
            size=len(que)
            vec=[]
            while size:
                root=que.popleft()
                vec.append(root.val)
                size-=1
                if root.left:que.append(root.left)
                if root.right:que.append(root.right)


            result.append(vec)

    return result
    # 自底向上遍历  return result [::-1]

# 二叉树的右视图
def rightTravelsal(self,root:TreeNode):
    if root is not None:
        que=deque()
        result=[]
        que.append(root)
        while len(que)>0: # 不为空 直接pop，但是要记录pop几个元素
            size=len(que)
            vec=[]
            while size:
                root=que.popleft()
                vec.append(root.val)
                size-=1
                if root.right:que.append(root.right)

            result.append(vec)
    return result

# 二叉树的层平均值
def averageTravelsal(self,root:TreeNode):
    if root is not None:
        que=deque()
        result=[]
        que.append(root)
        while len(que)>0: # 不为空 直接pop，但是要记录pop几个元素
            size=len(que)
            vec=[]
            while size:
                root=que.popleft()
                vec.append(root.val)
                size-=1
                if root.left:que.append(root.left)
                if root.right:que.append(root.right)
            result.append(sum(vec)/len(vec))
    return result
   

# 在每行树中找最大值
def maxTravelsal(self,root:TreeNode):
    if root is not None:
        que=deque()
        result=[]
        que.append(root)
        while len(que)>0: # 不为空 直接pop，但是要记录pop几个元素
            size=len(que)
            vec=[]
            while size:
                root=que.popleft()
                vec.append(root.val)
                size-=1
                if root.left:que.append(root.left)
                if root.right:que.append(root.right)
            result.append(max(vec))
    return result

# 让每个节点的next指向右侧节点
def rightnext(self,root:TreeNode):
    if root is not None:
        que=deque()

        que.append(root)
        while len(que)>0: # 不为空 直接pop，但是要记录pop几个元素
            temp=None
            size=len(que)
            while size:
                root=que.popleft()
                if temp:
                    temp.next=root
                temp=root
                size-=1
                if root.left:que.append(root.left)
                if root.right:que.append(root.right)


def maxdepth(self,root:TreeNode):
    if root is None:return[]
    depth=0
    que=deque()
    que.append(root)
    while len(que)>0:
        depth+=1
        size=len(que)
        while size:
            root=que.popleft()
            size-=1
            if root.left:que.append(root.left)
            if root.right:que.append(root.right)
    return depth

def mindepth(self,root:TreeNode):
    if root is None:return[]
    depth=0
    que=deque()
    que.append(root)
    while len(que)>0:
        depth+=1
        size=len(que)
        while size:
            root=que.popleft()
            size-=1
            if root.left:que.append(root.left)
            if root.right:que.append(root.right)
            elif not root.left and not root.right:
                return depth

    return depth

N叉树的层序遍历

首先创建个N叉树

 def insertN(self,data,i,N):
    if self.val :
        if i < len(data):
            while i<=N:
                self.children.append(TreeNode(data[i]))
                i+=1
            for child in self.children:
                child.insertN(data,i,N)
        else:
            self.children=None

def NlevelorderTravelsal(self,root:TreeNode):
    if root is not None:
        que=deque()
        result=[]
        que.append(root)
        while len(que)>0: # 不为空 直接pop，但是要记录pop几个元素
            size=len(que)
            vec=[]
            while size:
                root=que.popleft()
                vec.append(root.val)
                size-=1
                if root.children:
                    for child in root.children:
                        que.append(child)
        result.append(vec)
        return result

翻转二叉树（层次遍历的方法）

 def reverseTree(self,root:TreeNode):# 镜像
        # 利用队列，在层序遍历时，获取左右节点之后直接做交换
        if root is not None:
            que=deque()
            que.append(root)
            while len(que)>0: # 不为空 直接pop，但是要记录pop几个元素
                size=len(que)
                while size:
                    root=que.popleft()
                    root.left,root.right=root.right,root.left
                    size-=1
                    if root.left:que.append(root.left)
                    if root.right:que.append(root.right)

        return root

对称二叉树

class solution:
    def symmetricTree(self,left:TreeNode,right:TreeNode)->bool:
        # 先考虑节点有空的情况
        if left is None and right is  None:
            return  True
        elif left is None and right is not None:
            return False
        elif right is None and left is not None:
            return False
        # 再考虑节点值不相等的情况
        elif left.val != right.val:
            return False
        # 最后
        # 确定单层递归的逻辑
        # 此时才进入单层递归的逻辑，单层递归的逻辑就是处理
        # 左右节点都不为空，且数值相同的情况。
        # 比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
        # 比较内侧是否对称，传入左节点的右孩子，右节点的左孩子。
        # 如果左右都对称就返回true ，有一侧不对称就返回false 。
        else:
            if self.symmetricTree(left.left,right.right) and self.symmetricTree(left.right,right.left):
                return True

            else:return False