二叉树的遍历

一.深度优先

给定一个二叉树的根节点root，将遍历答案返回到list集合中

public class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode() {}
      TreeNode(int val) { this.val = val; }
      TreeNode(int val, TreeNode left, TreeNode right) {
          this.val = val;
          this.left = left;
          this.right = right;
      }
  }

1.前序遍历

前序的规则：根结点 —> 左子树 —> 右子树。

递归

      List<Integer> list =new ArrayList<>();//答案集合
    public void preOrder(List list,TreeNode root){//前序遍历：递归。先根->左->右
      if(root==null) return ;
      list.add(root.val);
      preOrder(list,root.left);
      preOrder(list,root.right);
    }

迭代

public void preOrder(TreeNode root) {//前序遍历：迭代。先根->左->右
      Stack<TreeNode> stack =new Stack<>();
      List<Integer> list = new ArrayList<>();//答案集合
      TreeNode node =root;//记录节点压入栈中的辅助节点
       if(node!=null){
           stack.push(node);//将根节点存入栈中
           while(!stack.isEmpty()){
             node = stack.pop();
             list.add(node.val);//根节点出栈
             if(node.right!=null){//先压入右边节点(lifo)
                 stack.push(node.right);
             }  
             if(node.left!=null){
                 stack.push(node.left);
             }  
           }
       }
    }

2.中序遍历

中序遍历规则：左子树 —> 根节点—> 右子树。

递归

    List<Integer> list = new ArrayList<>();//答案集合
      public void inOrder(TreeNode root){//中序遍历：递归。先根->左->右
          if(root==null) return;
          inOrder(root.left);
          list.add(root.val);
          inOrder(root.right);
      }

非递归

public void inOrder(TreeNode root){
	        Stack<TreeNode> stack = new Stack<>();
	        List<Integer> list  = new Arraylist<>();//答案集合
	        TreeNode node =root;//记录节点压入栈中的辅助节点
	        while(node != null || !stack.empty()){
	            while (node != null){
	                stack.push(node);
	                node = node.left;
	            }
	            if(!stack.empty()){
	                node = stack.pop();//弹出左节点
	                list.add(node.val);
	                node = Node.right;//有节点
	            }
	        }
         }

3.后序遍历

后序遍历规则：左子树 —> 右子树—> 根节点。

递归

    List<Integer> list = new ArrayList<>();//答案集合
    public void postOrder(List list,TreeNode root){//后序遍历：递归。先左->右->根
        if(root==null)  return ;
        postOrder(list,root.left);
        postOrder(list,root.right);
        list.add(root.val);
    }

非递归

public void postOrder(TreeNode root){
         Stack<TreeNode> stack =new Stack<>();
		 Stack<TreeNode> stack2 =new Stack<>();
		 List<Integer> list = new ArrayList<>();//答案集合
		 TreeNode node =root;
		 while(node ! = null ||!stack.isEmpty()) {
			 while(node!=null) {
				 /*
				  * 利用两个栈在stack2中将左，右顺序压栈
				  */
				 stack.push(node);
				 stack2.push(node);
				 node=node.right;
			 }
			 if(!stack.isEmpty()) {
				 node=stack.pop();//弹出左子节点
				 node=node.left;
			 }
		 }
		 while(!stack2.isEmpty()) {
			 node=stack2.pop();
			 list.add(node.val);
		 }
	}

二.广度优先

1.层遍历

  List<List<Integer>> list =new ArrayList<>();//答案集合
  
    public void levelOrder(TreeNode root){//层序遍历
        if(root==null) return;//终止条件

		Queue<TreeNode> q =new LinkedList<>();//记录当前节点的队列
		q.offer(root);
		
        while(!q.isEmpty()) {//当队列不为空
            int  size =q. size();
            List<Integer> list1 =new ArrayList<>();//记录每层的节点元素
			
            for(int i =0;i<size;i++){//层数的元素个数，全部遍历放入list1
            TreeNode tmp =q.poll();//取出队列中的节点作为当前节点
            list1.add(tmp.val);//添加当层的节点元素
			/*
            *记录每层节点并放入队列中
            */
            if(tmp.left!=null) {
				q.offer(tmp.left);
			}
			if(tmp.right!=null) {
				q.offer(tmp.right);
			}
            }
            list.add(list1);//将每层节点放入集合中。
		}
   }