二叉树基本操作

递归实现：

     public List preorderTraversal(TreeNode root) {
        List res = new ArrayList<>();
        preOrder(root, res);
        return res;
    }

    public void preOrder(TreeNode root, List res) {
        if (root == null)
            return;
        //先打印当前节点，然后打印左子树，最后再打印右子树
        res.add(root.val);
        preOrder(root.left, res);
        preOrder(root.right, res);
    }

利用栈实现

   public List preorderTraversal(TreeNode root) {
        List res = new ArrayList<>();
        //加个边界条件判断
        if (root == null)
            return res;
        Stack stack = new Stack<>();
        stack.push(root);//压栈
        while (!stack.empty()) {
            TreeNode t1 = stack.pop();//出栈
            res.add(t1.val);
            if (t1.right != null) {
                stack.push(t1.right);
            }
            if (t1.left != null) {
                stack.push(t1.left);
            }
        }
        return res;
    }

递归实现

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

    public void inOrderTraversal(TreeNode root, List res) {
        if (root == null)
            return;
        //先打印左子树，然后打印当前节点，最后再打印右子树
        inOrderTraversal(root.left, res);
        res.add(root.val);
        inOrderTraversal(root.right, res);
    }

栈实现

    public List inorderTraversal(TreeNode root) {
        List res = new ArrayList<>();
        //加个边界条件判断
        if (root == null)
            return res;
        Stack stack = new Stack<>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            if (!stack.isEmpty()) {
                root = stack.pop();
                res.add(root.val);
                root = root.right;
            }
        }
        return res;
    }

递归

    void dfs(TreeNode* root, vector& ret){
        if(root == nullptr){
            return;
        }
        dfs(root->left,ret);        // 左
        dfs(root->right,ret);       // 右
        ret.push_back(root->val);   // 根
    }

非递归

vector postorderTraversal(TreeNode* root) {
       TreeNode* p = root;
       vector ret;
       stack s1;
       stack s2;
       if(p!=nullptr){
           s1.push(p);      // 头结点先压入s1中
       }
       while(!s1.empty()){
           p = s1.top();		// 每次从s1中弹出一个结点
           s1.pop();			// 弹出的结点压入s2中
           s2.push(p);

           if(p->left != nullptr){      // 先压左
               s1.push(p->left);
           }
           if(p->right != nullptr){
               s1.push(p->right);       // 再压右
           }
       }

       // 这样s1的顺序就是 根右左，s2的顺序就是左右根
       while( !s2.empty() ){
           ret.push_back(s2.top()->val);
           s2.pop();
       }
       return ret;
    }