树的各种遍历实现

树的遍历有前序，后序，广度，以及中序遍历。下边将利用递归以及非递归的方式实现这几种遍历方式。

1.前序遍历

递归写法：

/**
 * 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> preorderTraversal(TreeNode* root) {
        vector<int> res;
        Traversal(root, res);
        return res;
    }
    
    void Traversal(TreeNode *root, vector<int> &res)
    {
        if(!root) return ;
        res.push_back(root->val);
        Traversal(root->left, res);
        Traversal(root->right, res);
    }
};

非递归写法： 

/**
 * 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> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root) return res;
        stack<TreeNode *>stk;
        stk.push(root);
        
        while(!stk.empty()){
            TreeNode* s = stk.top();
            stk.pop();
            res.push_back(s->val);
            if(s->right) stk.push(s->right);
            if(s->left) stk.push(s->left);
        }
        
        return res;
    }
};

非递归写法主要要弄清楚树遍历的顺序，这样就很容易写出来相应的stack的压出栈顺序。

2.中序遍历

递归写法

/**
 * 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> inorderTraversal(TreeNode* root) {
        vector<int> res;
        Traversal(root, res);
        return res;
    }
    
    void Traversal(TreeNode *root, vector<int> &res)
    {
        if(!root) return ;
        Traversal(root->left, res);
        res.push_back(root->val);
        Traversal(root->right, res);
    }
};

 非递归写法

/**
 * 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> inorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root) return res;
        TreeNode *cur = root;
        stack<TreeNode *>stk;
        
        while(cur || !stk.empty()){
            if(cur){
                stk.push(cur);
                cur = cur->left;
            }else{
                cur = stk.top();
                stk.pop();
                res.push_back(cur->val);
                cur = cur->right;
            }
        }
        
        return res;
    }
};

非递归写法要注意stack弹出栈的操作，这里的思路是这样的：当左边没有元素时弹出，但是弹出后如果右边不是空则压入右边，如果右边为空则继续弹出，也就成了以上所写的代码了。这里无法使用前序遍历那种仅仅根据压栈出栈的顺序写stack的原因在于前序本质还是从上至下的，不会产生重复遍历的过程。而中序从下至上，如果仅仅push(left), push(mid),push(right)这种方法会导致重复访问节点的问题。

3.后序遍历

递归写法

/**
 * 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;
        Traversal(root, res);
        return res;
    }
    
    void Traversal(TreeNode *root, vector<int> &res)
    {
        if(!root) return ;
        Traversal(root->left, res);
        Traversal(root->right, res);
        res.push_back(root->val);
    }
};

非递归写法： 

/**
 * 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) {
        TreeNode *cur = root;
        vector<int> res;
        if(!root) return res;
        stack<TreeNode *>stk;
        
        stk.push(root);
        while(!stk.empty()){
            TreeNode *t = stk.top();
            stk.pop();
            res.push_back(t->val);
            if(t->left)
                stk.push(t->left);
            if(t->right)
                stk.push(t->right);
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

非递归写法利用前序遍历的思想进行编写，然后进行reverse。因为前序遍历中弹出的条件更容易判断，用完就可以弹出。所以利用前序遍历更容易

4.广度搜索

/**
 * 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<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int> >res;
    
        queue<TreeNode *> q;
        if(!root) return res;
        q.push(root);
        
        while(!q.empty()){
            int count = q.size();
            vector<int> r;
            while(count){
                TreeNode *t = q.front();
                r.push_back(t->val);
                q.pop();
                if(t->left) q.push(t->left);
                if(t->right) q.push(t->right);
                count--;
            }
            res.push_back(r);
        }
        
        return res;
    }
};

利用队列实现。