A variety of traversing the tree

1. preorder traversal

(1) written recursively

    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) non-recursive wording

    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. preorder

 (1) recursive

    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) non-recursive

    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. postorder

 (1) recursive

    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) non-recursive

    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();//But it does not obtain a node stack 
            IF (cur.right == null || cur.right Prior ==) { // Analyzing the right node of the node is visited 
                stack.pop (); 
                res.add (CUR .val); 
                Prior = CUR;                
            } 
            the else { 
                CUR = cur.right;
                 the 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 (); // acquired node but not let the stack 
            IF (cur.right == null || cur.right Prior ==) { // Analyzing the right node of the node is visited 
                stack .pop (); 
                res.add (Cur.Val); 
                Prior = CUR; 
                CUR = null ; 
            } 
            the else { 
                CUR = cur.right; 
            } 
                
        } 
        return RES; 
    }

 

4. traverse the level

    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;
    }