二叉树前中后层序遍历递归非递归java实现

二叉树前中后层序遍历递归非递归java实现

public class TreeOrder {
    public void preorder(TreeNode root){
        if(root==null) return;
        System.out.println(root.val);
        preorder(root.left);
        preorder(root.right);
    }

    public void preorderNon(TreeNode root){
        if(root==null) return;
        Stack<TreeNode> stack = new Stack<>();
        while(root!=null || !stack.isEmpty()){
            while(root!=null){
                System.out.println(root.val);
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            root = root.right;
        }
    }

    public void preorderNon2(TreeNode root){
        if(root==null) return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            root = stack.pop();
            System.out.println(root.val);
            if(root.right!=null) stack.push(root.right);
            if(root.left!=null) stack.push(root.left);
        }
    }

    public void inorder(TreeNode root){
        if(root==null) return;
        inorder(root.left);
        System.out.println(root.val);
        inorder(root.right);
    }

    public void inorderNon(TreeNode root){
        if(root==null) return;
        Stack<TreeNode> stack = new Stack<>();
        while(root!=null || !stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            System.out.println(root.val);
            root = root.right;
        }
    }

    public void morris(TreeNode root){
        if(root==null) return;
        while(root!=null){
            if(root.left!=null){
                TreeNode rightmost = root.left;
                while(rightmost.right!=null && rightmost.right!=root){
                    rightmost = rightmost.right;
                }
                if(rightmost.right==null){
                    rightmost.right = root;
                    root = root.left;
                }else{
                    System.out.println(root.val);
                    root = root.right;
                    rightmost.right = null;
                }
            }else{
                System.out.println(root.val);
                root = root.right;
            }
        }
    }
	
    public void postorder(TreeNode root){
        if(root==null) return;
        postorder(root.left);
        postorder(root.right);
        System.out.println(root.val);
    }
	//交换左右子树的前序遍历的倒排，就是后序遍历
    public void postorderNon(TreeNode root){
        if(root==null) return;
        Stack<TreeNode> stack = new Stack<>();
        Stack<TreeNode> res = new Stack<>();
        while(root!=null || !stack.isEmpty()){
            while(root!=null){
                res.push(root);
                stack.push(root);
                root = root.right;
            }
            root = stack.pop();
            root = root.left;
        }
        while(!res.isEmpty()){
            System.out.println(res.pop().val);
        }
    }

    public void postorderNon2(TreeNode root){
        if(root==null) return;
        Stack<TreeNode> stack = new Stack<>();
        Stack<TreeNode> res = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            res.push(node);
            if(node.left!=null) stack.push(node.left);
            if(node.right!=null) stack.push(node.right);
        }
        while(!res.isEmpty()){
            System.out.println(res.pop().val);
        }
    }

    public void levelorder(TreeNode root){
        if(root==null) return;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            while(size>0){
                TreeNode node = queue.poll();
                System.out.println(node.val);
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
                size--;
            }
        }
    }

    public static void main(String[] args) {
        TreeOrder or = new TreeOrder();
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(7);
        
//        or.preorder(root);
//        or.preorderNon(root);
//        or.preorderNon2(root);
//        or.inorder(root);
//        or.inorderNon(root);
        or.morris(root);
//        or.postorder(root);
//        or.postorderNon(root);
//        or.postorderNon2(root);
//        or.levelorder(root);
    }
}
class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode() {
    }

    public TreeNode(int val) {
        this.val = val;
    }
}
//输出
//preorder:1245367
//inorder:4251637
//postorder:4526731
//levelorder:1234567