二叉树的遍历

二叉树的层序遍历

1、对传来的根节点进行判断：

if not root：
	return list

2、
建立一个列表list，存放所有的result
建立了一个result：存放单层的val

dq=deque([root])				#使用双向队列duque，里面有根节点root 
while dq:						#当队列中有值的时候，一直dq，每走一层while，相当于遍历一层
	result=[]					#每一层都要有一个列表来放val值
	size=len(dq)
	for _ in range(size)：		#遍历一层内的所有节点
		cur=dp.popleft()		#取最左边的
		result.append(cur.val)	#一层内的单个节点，加到result里面
		
		#把所遍历到节点的左右节点加到dp里面。
		if cur.left:
			dp.append(cur.left)
		if cur.right:
			dp.append(cur.right)

3、最后将放满一层内的val值result 加到list

4、完整代码

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        list=[]
        if not root:
            return list
        dp=deque([root])
        while dp:
            result=[]
            length=len(dp)
            for _ in range(length):
                cur=dp.popleft()
                result.append(cur.val)
                if(cur.left):
                    dp.append(cur.left)
                if(cur.right):
                    dp.append(cur.right)
            list.append(result)
        return list

二叉树的【前中后序】遍历

递归遍历

前序：

def fun(node):

1、首先，编写递归函数fun(),需要传入的参数只有节点node

def fun(node):
	if node ==None：
		return

2、递归的终止条件：所遍历到的节点为null，停止此次递归
3、使用fun(root) 开始调用前序函数，是先从根节点，再到左右节点，则递归的逻辑：

#创建一个空列表list
list.append(node.val) #先根节点
fun(node.left)		  #左边递归
fun(node.right)		  #右边递归

4、调用函数，返回列表

fun(root)
return list

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        list=[]
        def fun(node):
            if node==None:
                return
            list.append(node.val)
            fun(node.left)
            fun(node.right)
        fun(root)    
        return list

中序、后序
与前序相比，只有递归逻辑发生改变，
中序是左根右，所以代码如下

    def fun(node):
       if node==None:
           return
       fun(node.left)
       list.append(node.val)
       fun(node.right)

有左边就先走左边,走到左空走自己，走完自己走右面：
传入1后：走fun(1.left) 也就算2、走fun(2.left) 也就是3，一直走到3.left
3.left为空，退出一层递归，输出3.val
按照代码，走fun(3.right)，为空，返回、返回【此时黄色框走完】

以上走过fun(2.left)，接着走2.val ，之后走fun(2.right)

迭代遍历

迭代学习
使用栈
先序:
根左右，先出根，再进栈右左，再出依次出
前序：
1、建立res列表，跟中间过程的stack。判断根节点是否为空

result=[]
stack=[]
if not root:
    return res

2、已知不为空，先进根节点栈

stack.append(root)

3、当stack不为空，不断执行，直到栈为空了
【根】 正常出栈
【左右】进栈右左，再出依次出

while stack:
    cur = stack.pop()
    res.append(cur.val)
    if curr.right:
        stack.append(cur.right)
    if curr.left:
        stack.append(cur.left)

完整代码：

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        result=[]
        stack=[]
        if not root:
            return result
        stack.append(root)
        while stack:
            cur=stack.pop()
            result.append(cur.val)
            if cur.right:
                stack.append(cur.right)
            if cur.left:
                stack.append(cur.left)
        return result

中序

77.left=null 即记号1时：弹出栈顶元素，计入res。cur到达cur.right 即记号2时
下层弹出99，因为cur为空，弹出此时的栈顶 即99，计入res；
之后 99.right=90 不为空 记号2，进入while rur：判断，入栈 到达90.left为空；弹出栈顶

左：左的left为空，作为左分支正常弹出
根：指针转移到左.right，还是空，导致自己进入下层循环的cur为空，成为栈顶，然后弹出
右：虽然根弹出了，但根的被记录了下来，他的右可以追溯，不为空：在下层循环中作为右枝进while null来弹出栈，被计入res

# 迭代解法
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        result=[]
        stack=[]
        if not root:
            return result    
        cur = root
        while cur or len(stack):
            while cur:				#若cur不为空，则左枝一直进栈，直到cur为空
                stack.append(cur)
                cur = cur.left		#记号1
            node = stack.pop()		
            result.append(node.val) 
            cur = node.right		#记号2
        return result

后序

# 迭代解法
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        result=[]
        stack=[]
        if not root:
            return result
        stack.append(root)
        while stack:
            curr = stack.pop()
            result.append(curr.val)
            if curr.left:
                stack.append(curr.left)
            if curr.right:
                stack.append(curr.right)
        result.reverse()
        return result