LeetCode：二叉树的前、中、后序遍历

描述：

-------------------------------------------------------

前序遍历：

Given a binary tree, return the preorder traversal of its nodes' values.

给出一棵二叉树，返回其节点值的前序遍历。

样例

给出一棵二叉树 {1,#,2,3},

   1
    
     2
    /
   3

 返回 [1,2,3].

----------------------------------------------------------

中序遍历：

Given a binary tree, return the inorder traversal of its nodes' values.

样例

给出二叉树 {1,#,2,3},

   1
    
     2
    /
   3

返回 [1,3,2].

------------------------------------------------------

后序遍历：

Given a binary tree, return the postorder traversal of its nodes' values.

给出一棵二叉树，返回其节点值的后序遍历。 

样例

给出一棵二叉树 {1,#,2,3},

   1
    
     2
    /
   3

返回 [3,2,1]

 C++解题思路：

用一个栈stack就可以解决问题，vector使用.push_back方法来将元素压入栈中。

前序：

 递归一：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> sol;
    
    void recurseSol(TreeNode * root) {
        if (!root) {
            return;
        }
        sol.push_back(root->val);
        recurseSol(root->left);
        recurseSol(root->right);
    }
    
    vector<int> preorderTraversal(TreeNode* root) {
        recurseSol(root);
        return sol;
    }
};

非递归与递归二：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //非递归
    vector<int> preorderTraversal2(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode *p = root;
        while (p || !s.empty()) {
            while (p){
                s.push(p);
                res.push_back(p->val);
                p = p->left;
            }
            p = s.top();
            s.pop();
            p = p->right;
        }
        return res;
    }
    //递归
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> vec1,vec2;
        if (!root) {
            return vec1;
        }
        int r = root->val;
        vec1 = preorderTraversal(root->left);
        vec2 = preorderTraversal(root->right);
        
        vec1.insert(vec1.begin(),r);
        vec1.insert(vec1.end(),vec2.begin(),vec2.end());  
        return vec1;
    }
};

中序：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //非递归
    vector<int> inorderTraversal2(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode *p = root;
        while (p || !s.empty()) {
            while (p) {
                s.push(p);
                p = p->left;
            }
            p = s.top();
            s.pop();
            res.push_back(p->val);
            p = p->right;
        }
        return res;
    }
    //递归
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> vec1,vec2;
        if (!root) {
            return vec1;
        }
        vec1 = inorderTraversal(root->left);
        vec1.push_back(root->val);
        vec2 = inorderTraversal(root->right);
        
        vec1.insert(vec1.end(),vec2.begin(),vec2.end());  
        return vec1;
    }
};

后序：

后序非递归采用的思路是先将二叉树排序为（根-右-左），然后利用reverse函数反转vector的序列。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //非递归
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if (!root){
            return res;
        }
        stack<TreeNode*> s;
        TreeNode *p = root;
        s.push(p);
        while (!s.empty()) {
            p = s.top();  
            res.push_back(p->val);
            s.pop();
            if(p->left)
                s.push(p->left);
            if(p->right)
                s.push(p->right);
        }
        reverse(res.begin(),res.end());
        return res;
            
    }
    
    //递归
    vector<int> postorderTraversal2(TreeNode* root) {
        vector<int> vec1,vec2;
        if (!root) {
            return vec1;
        }
        vec1 = postorderTraversal(root->left);
        vec2 = postorderTraversal(root->right);        
        
        vec1.insert(vec1.end(),vec2.begin(),vec2.end());  
        vec1.push_back(root->val);
        return vec1;
    }
};

JAVA解题思路：

递归实现二叉树的遍历相对简单，如果用list存放遍历结果，每次递归使用list.addall()方法即可添加“子树”;

使用非递归实现遍历比较复杂，这里我利用栈（stack）来实现节点的存取操作，使其顺利add进入list中返回。

代码如下：

package week1;

import java.awt.List;
import java.util.ArrayList;
import java.util.Stack;

public class 二叉树遍历 {
    /**
     * Definition of TreeNode:
     */
    public class TreeNode {
        public int val;
        public TreeNode left, right;

        public TreeNode(int val) {
            this.val = val;
            this.left = this.right = null;
        }
    }
    
    
//==============先序遍历=======================================================
    /*
     * @param root: A Tree
     * @return: Preorder in ArrayList which contains node values.
     * 递归
     */
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> list = new ArrayList<Integer>();
        if (root == null) return list;
        list.add(root.val);  //先将根节点放入
        if(root.left != null) list.addAll(preorderTraversal(root.left)); //递归左子树，放入list中
        if(root.right != null) list.addAll(preorderTraversal(root.right));  //递归右子树，放入list中
        return list;
    }
    
    /*
     * @param root: A Tree
     * @return: Preorder in ArrayList which contains node values.
     * 非递归
     */
    public ArrayList<Integer> preorderTraversal2(TreeNode root) {
        // write your code here
        ArrayList<Integer> res = new ArrayList<Integer>();
        if(root == null) return res;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);  //入栈操作
        while(!stack.empty()){
            TreeNode node = stack.pop(); //当前节点出栈
            res.add(node.val);
            if(node.right != null) stack.push(node.right);  //先入右子树节点，因为先进后出
            if(node.left != null) stack.push(node.left);
        }
        return res;
    }
    
    
//==============中序遍历=======================================================
    /**
     * 递归
     */
    public ArrayList<Integer> inorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> list = new ArrayList<Integer>();
        if (root == null) return list;
        if(root.left != null) list.addAll(inorderTraversal(root.left));
        list.add(root.val);
        if(root.right != null) list.addAll(inorderTraversal(root.right));
        return list;
    }
    
    /**
     * 非递归
     */
    public ArrayList<Integer> inorderTraversal2(TreeNode root) {
        // write your code here
        ArrayList<Integer> res = new ArrayList<Integer>();
        if(root == null) return res;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode node = root;
        while(node != null || !stack.empty()){
            while(node != null){   //一直遍历左子树入栈，直到左叶子节点，才开始下一步出栈
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            res.add(node.val);
            node = node.right; //左-中-右
        }
        return res;
    }
    
    
//==============后序遍历=======================================================
    /**
     * 递归
     */
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> list = new ArrayList<Integer>();
        if (root == null) return list;
        if(root.left != null) list.addAll(postorderTraversal(root.left));
        if(root.right != null) list.addAll(postorderTraversal(root.right));
        list.add(root.val);
        return list;
    }
    
    /**
     * 非递归
     */
    public ArrayList<Integer> postorderTraversal2(TreeNode root) {
        // write your code here
        ArrayList<Integer> list = new ArrayList<Integer>();
        if (root == null) return list;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.empty()){
             TreeNode node = stack.pop();
             list.add(0,node.val);  //此方法有两个参数，第一个参数指定插入位置，第二个为插入值，这里一直在0位置插入，意思是最新插入的一直在list的最前面，之前插入的到了后面
             if(node.left != null) stack.push(node.left);
             if(node.right != null) stack.push(node.right);
        }
        return list;
    }
}

至此完成二叉树的遍历。  by still