树的各种遍历

1. 前序遍历

（1）递归写法

    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> re = new ArrayList<Integer>();
        pre(root,re);
        return re;
    }
    private void pre(TreeNode root,List<Integer> re){
        if(null == root){
            return;
        }
        re.add(root.val);
        pre(root.left,re);
        pre(root.right,re);
    }

（2）非递归写法

    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        if(null!= root){
            stack.push(root);
        }        
        while(!stack.isEmpty()){
            TreeNode cur = stack.pop();
            res.add(cur.val);
            if(null!= cur.right){
                stack.push(cur.right);
            }
                
            if(null != cur.left){
                stack.push(cur.left);
            }          
        }
        return res;
    }    

 

    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode cur =root;
        while(null!= cur||!stack.isEmpty()){
            while(null!=cur){
                res.add(cur.val);
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            cur = cur.right;
                
        }
        return res;
    }   

 

2.中序遍历

 （1） 递归

    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorderT(root,res);
        return res;

    }
    private void inorderT(TreeNode root,List list){
        if(null!=root){
            inorderT(root.left,list);
            list.add(root.val);
            inorderT(root.right,list);
        }
    }

（2）非递归

    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode cur = root;
        while(null!= cur || !stack.isEmpty()){
            while(null!=cur){
                stack.push(cur);
                cur=cur.left;
            }
            cur= stack.pop();
            res.add(cur.val);
            cur= cur.right;
        }
        return res;
    }

 

3.后序遍历

 （1）递归

    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        post(root,res);
        return res;
    }
    private void post(TreeNode root,List<Integer> re){
        if(null==root){
            return;
        }
        post(root.left,re);
        post(root.right,re);
        re.add(root.val);
    }

（2）非递归

    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode cur =root;
        TreeNode prior = null;
         while(null!=cur){
            stack.push(cur);
            cur = cur.left;
        }
        while(!stack.isEmpty()){     
            cur = stack.peek();//取得结点但不让它出栈
            if(cur.right == null || cur.right == prior){//判断该节点的右结点是否访问过
                stack.pop();
                res.add(cur.val);
                prior = cur;               
            }
            else{
                cur = cur.right;
                while(null!= cur){
                    stack.push(cur);
                    cur = cur.left;
                }
            }
                
        }
        return res;
    }

 

    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode cur =root;
        TreeNode prior = null;
        while(null!= cur||!stack.isEmpty()){
            while(null!=cur){
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.peek();//取得结点但不让它出栈
            if(cur.right == null || cur.right == prior){//判断该节点的右结点是否访问过
                stack.pop();
                res.add(cur.val);
                prior = cur;
                cur = null;
            }
            else{
                cur = cur.right;
            }
                
        }
        return res;
    }

 

4. 层次遍历

    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {//树 my
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        ArrayList<Integer> result = new ArrayList<Integer>();
        TreeNode node =root;
        while(null != node){
            result.add(node.val);
            if(null != node.left){
                queue.add(node.left);
            }
            if(null != node.right){
                queue.add(node.right);
            }
            node = queue.poll();
        }

        return result;
    }

 

相关题

LeetCode144. Binary Tree Preorder Traversal

LeetCode94. Binary Tree Inorder Traversal

LeetCode145. Binary Tree Postorder Traversal

LeetCode102. Binary Tree Level Order Traversal