二叉树的前\中\后\层序遍历

前序遍历

//先序遍历
//递归方法
    public static void prevOrder(Node root) {
        if (root == null) {
            return;//空树不需要遍历
        }
        //先访问根节点
        //再递归左子树
        //再递归右子树
        System.out.print(root.val);
        prevOrder(root.left);
        prevOrder(root.right);
    }

 //非递归前序,迭代法,使用栈
    public static void prevOrder2(Node root) {
        Stack<Node> stack = new Stack<>();
        Node cur = root;
        while (cur != null || !stack.empty()) {
            while (cur != null) {
                stack.push(cur);
                System.out.print(cur.val);
                cur = cur.left;
            }
            cur = stack.pop();
            cur = cur.right;
        }
    }

中序遍历

//中序遍历
//递归法
    public static void inOrder(Node root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);//先遍历左子树
        System.out.print(root.val);//访问根节点
        inOrder(root.right);//再遍历右子树
    }

    //非递归中序,迭代法
    public static void inOrder2(Node root) {
        Stack<Node> stack = new Stack<>();
        Node cur = root;
        while (cur != null || !stack.empty()) {
            while (cur != null) {
                stack.push(cur);//入栈
                cur = cur.left;//继续向左
            }
            cur = stack.pop();//为null出此时栈顶元素
            System.out.print(cur.val);//并打印
            cur = cur.right;//指向右边
        }
    }
//迭代法,规定返回值为List<Character>
    public static List<Character> inOrder3(Node root) {
        List<Character> list = new ArrayList<>();
        Stack<Node> stack = new Stack<>();
        Node cur = root;
        while (cur != null || !stack.empty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            list.add(cur.val);
            cur = cur.right;
        }
        return list;
    }

  

后序遍历

  //后序遍历
  //递归方法
    public static void postOrder(Node root) {
        if (root == null) {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val);
    }

    //非递归后序遍历,迭代法
    public static void postOrder1(Node root) {
        Stack<Node> stack = new Stack<>();
        Node cur = root;
        Node flg = null;
        while (cur != null || !stack.empty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.peek();
            if (cur.right == null || cur.right == flg) {
                System.out.print(cur.val);
                stack.pop();
                flg = cur;//标记打印的前一个值
                cur = null;
            } else {
                cur = cur.right;
            }
        }
    }
//迭代法,使用栈和集合
    public static List<Character> postOrder2(Node root) {
        List<Character> list = new ArrayList<>();
        Stack<Node> stack = new Stack<>();
        Node cur = root;
        while (cur != null || !stack.empty()) {
            while (cur != null) {
                list.add(cur.val);
                stack.push(cur.left);
                cur = cur.right;
            }
            cur = stack.peek();
            stack.pop();
        }
        Collections.reverse(list);//逆置输出结果
        return list;
    }

层序遍历

//层序遍历
    public static void levelOrderTraversal(Node root) {
        Queue<Node> queue = new LinkedList<>();//使用队列
        if (root != null) {
            queue.offer(root);//先入根节点
        }
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            if (cur == null) {
                return;
            }
            System.out.print(cur.val);
            if (cur.left != null) {
                queue.offer(cur.left);
            }
            if (cur.right != null) {
                queue.offer(cur.right);
            }
        }
    }