一. 构造二叉树

构造二叉树，先得要构建一个树的节点，定义一个TreeNode：

public class TreeNode {  
    int val;  
    TreeNode left;  
    TreeNode right;  
    TreeNode(int x) { val = x; }  
}  

插入节点，建立新树：

TreeNode root = new TreeNode(1);  
root.left = new TreeNode(2); 

二. 二叉树的递归遍历算法

三种遍历方法，先序，中序，后序，都是用递归方法：

1. 先序遍历

public void preorderTraversal(TreeNode root,ArrayList<Integer> ret){    
       int rootvalue = root.val; 
       ret.add(rootvalue); 
       if(root.left != null){  
           inorderTraversal(root.left,ret); 
       }      
       if(root.right != null){  
           inorderTraversal(root.right,ret); 
       }  
   }  

2. 中序遍历

public void inorderTraversal(TreeNode root,ArrayList<Integer> ret){     
    if(root.left != null){  
        inorderTraversal(root.left,ret); 
    }  
    int rootvalue = root.val; 
    ret.add(rootvalue); 
    if(root.right != null){  
        inorderTraversal(root.right,ret); 
    }  
}  

3.后序遍历

 public void postorderTraversal(TreeNode root,ArrayList<Integer> ret){   
     if(root.left != null){  
         inorderTraversal(root.left,ret); 
     }      
     if(root.right != null){  
         inorderTraversal(root.right,ret); 
     }  
     int rootvalue = root.val; 
     ret.add(rootvalue); 
 }  

三.二叉树的非递归遍历

非递归遍历的先序和中序遍历都是用栈实现。

1.先序遍历

二叉树的先序遍历其实就是深度遍历，如图所示：

用栈来实现。首先是将所有节点的左子树的元素全部都进栈，退出循环之后，先访问树的最左边的一个节点，也就是栈顶元素，并将它pop，然后将其右子树入栈。

public ArrayList<Integer> preorderTraversal(TreeNode root) {  
       ArrayList<Integer> list = new ArrayList<Integer>();  
        if(root == null)return list;  
        Stack<TreeNode> S = new Stack<TreeNode>();  
        TreeNode p = root;  
        while(p != null || !S.empty()){  
            while(p != null){  
                S.push(p);  
                list.add(p.val);  
                p = p.left;  
            }  
            p = S.pop();  
            p = p.right;  
        }  
        return list;  
    }  

2. 中序遍历

同样用栈来实现。它与先序遍历的区别是，先序是入栈的时候访问节点的value，而中序遍历是出栈的时候，访问节点的value。

public ArrayList<Integer> inorderTraversal(TreeNode root) {  
        ArrayList<Integer> list = new ArrayList<Integer>();  
        if(root == null)return list;  
        Stack<TreeNode> S = new Stack<TreeNode>();  
        TreeNode p = root;  
        while(p!=null || !S.empty()){  
            while(p!=null){  
                S.push(p);    
                p = p.left;  
            }  
            p = S.pop();  
            list.add(p.val);  
            p = p.right;    
        }  
        return list;  
    } 

3. 后序遍历

后序遍历是非递归遍历算法中最难理解的。它需要设置一个标记位，表明这棵子树已访问过。

四.二叉树的层次遍历

二叉树的层次遍历，用队列实现。
Leetcode-102的代码如下：

vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int> > ret;
    if(root == NULL)
    {
        return ret;
    }

    queue<TreeNode*> q;
    q.push(root);

    while(!q.empty())
    {
        int size = q.size();
        vector<int> level;
        for(int i=0;i<size;++i)
        {
            TreeNode* node = q.front();
            level.push_back(node->val);
            q.pop();
            if(node->left)
            {
                q.push(node->left);
            }
            if(node->right)
            {
                q.push(node->right);
            }               
        }
        ret.push_back(level);
    }
    return ret;
}