二叉树遍历

二叉树

1. 节点定义

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

2. 二叉树遍历

递归实现：

//先序遍历
public void preorder(TreeNode root, List<Integer> res) {
    if (root == null) {
        return;
    }
    res.add(root.val);
    preorder(root.left, res);
    preorder(root.right, res);
}

// 中序遍历
public void inorder_Traversal(TreeNode root) {
    if (root == null) return;
    inorder_Traversal(root.left);

    //访问节点的逻辑代码块
    System.out.print(root.val + " ");

    inorder_Traversal(root.right);
}

// 递归实现
public void postorder_Traversal(TreeNode root) {
    if (root == null) return;
    postorder_Traversal(root.left);
    postorder_Traversal(root.right);

    //访问节点的逻辑代码块
    System.out.print(root.val + " ");
}

非递归实现：

// 非递归实现 先序遍历
public void preorder(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    while (root != null || !stack.isEmpty()) {
        //当前节点不为空，则入栈，确保最后遍历到的节点没有左子节点
        //因为是前序遍历，所以再遍历到每个节点的时候，都可以先访问，再寻找其左右子节点。
        while (root != null) {
            System.out.print(root.val + " ");
            stack.push(root);
            root = root.left;
        }
        if (!stack.empty()) {
            //把这两步看成是一步，找到右节点，并把已处理的中节点从stack当中去除
            root = stack.pop();
            root = root.right;
        }
    }

}

// 非递归实现 中序遍历
public void Inorder(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    while (root != null || !stack.isEmpty()) {
        //当前节点不为空，则入栈，确保最后遍历到的节点没有左子节点
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
        //通过当前节点，跳到当前节点的右节点，因为是中序遍历，所以当前节点没有左节点的时候，就
        //可以访问当前节点
        if (!stack.empty()) {
            root = stack.pop();
            System.out.print(root.val + " ");
            root = root.right;
        }
    }
}
//先序遍历非递归
public void nonRecOrder(TreeNode node){
		if(node == null){
			return;
		}
		Stack<TreeNode> stack = new Stack<TreeNode>();
		stack.push(node);
		while(!stack.isEmpty()){
			//出栈和进栈
			TreeNode n = stack.pop();//弹出根结点
			//压入子结点
			System.out.print(n.val);
			if(n.rightChild!=null){
				stack.push(n.right);
				
			}
			if(n.left!=null){
				stack.push(n.left);
			}
		}
	}

//后序遍历
//先序遍历  根左右  如果放入时候进行根右左然后再放到一个栈中逆序输出就是一个左右根
   private static void postOrder(TreeNode root) {
        Stack<TreeNode> src = new Stack<TreeNode>();
        Stack<TreeNode> res = new Stack<TreeNode>();
        src.push(root);
        while(!src.isEmpty()){
            TreeNode p = src.pop();
            res.push(p);
            if(p.left != null){
                src.push(p.left);
            }
            if(p.right != null){
                src.push(p.right);
            }
        }
        //输出最终后序遍历的结果
        while(!res.isEmpty()){
            System.out.print(res.pop().val + " ");
        }
    }