二叉树的基本操作-前序遍历，中序遍历和后序遍历

1.遍历（前序，中序，后序）

前序遍历 ： 先遍历当前节点，再遍历当左节点，再遍历右节点

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root == null) return new ArrayList();
        List<Integer> list = new ArrayList<Integer>();
        preorder(root,list);
        return list;
        
    }

    private void preorder(TreeNode node,List<Integer> list) {
        if (node == null) return ;
        list.add(node.val);
        preorder(node.left,list);
        preorder(node.right,list);
    }
}




迭代：
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        if (root == null) return new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (root !=null || !stack.isEmpty()) {
            while (root!=null) {
                //因为前序遍历是根左右，根节点可以直接加入
                list.add(root.val);
                // 不断的加入左子树的根节点，然后压入栈，之后可以弹出栈获得节点，获取右边节点
                stack.push(root);
                root = root.left;
            }
            //将左子节点栈顶弹出
              root = stack.pop();
              root = node.right;                        
        }
        return list;
    }

}

##中序遍历  ：先遍历左节点，再遍历当前节点，再遍历右节点







/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        if(root == null) return new ArrayList<Integer>();
        // 迭代法  主要使用栈，从root一直压入左点到左节点为null
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (root!=null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            //跳出循环代表root的左子树压入完成,可以按照中序遍历 左 中 右 顺序，加入值(因为没有左节点了，所以加入本身值)          
               root = stack.pop();                     
            // 看下该节点有没有右节点，右节点又是按照之前循环来压入栈， 可以需要判断root 是否为null，因为一旦stack没有值后，stack.pop() 就是null，后面会空指针
                 list.add(root.val);
                 root = root.right;
            
        }    
        return list;    
    }
 
}
##后续遍历
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root == null) return new ArrayList();
        List list = new ArrayList<Integer>();
        postOrder(root,list);
        return list;

    }
    private void postOrder(TreeNode root,List<Integer> list) {
        if(root ==null ) return;
        postOrder(root.left,list);
        postOrder(root.right,list);
        list.add(root.val);
    }
}





/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root == null) return new ArrayList();
        List list = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode  prev = root;
        while(root!=null || !stack.isEmpty()){
            while (root !=null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();

            if (root.right == null || root.right == prev) {
                list.add(root.val);
                prev = root;
                root = null;
            } else {
                stack.push(root);
                root =root.right;
            }
        }
        return list;

    }
}