二叉树-----遍历（递归）

前序 中序 后序 遍历

实现

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param root TreeNode类 the root of binary tree
     * @return int整型vector<vector<>>
     */
    void first_traverse(TreeNode* root,vector<int> &v)
    {
        if(root != nullptr)
        {
            v.push_back(root->val);
            first_traverse(root->left,v);
            first_traverse(root->right,v);
        }
        
    }
    void second_traverse(TreeNode* root,vector<int> &v)
    {
        if(root != nullptr)
        {
            second_traverse(root->left,v);
            v.push_back(root->val);
            second_traverse(root->right,v);
        }
        
    }
    void third_traverse(TreeNode* root,vector<int> &v)
    {
        if(root != nullptr)
        {
            third_traverse(root->left,v);
            third_traverse(root->right,v);
            v.push_back(root->val);
        }
        
    }
    
    
    vector<vector<int> > threeOrders(TreeNode* root) {
        vector<vector<int>> v(3);
        first_traverse(root,v[0]);
        second_traverse(root,v[1]);
        third_traverse(root,v[2]);
        return v;
    }
};

层次遍历

原理

层次遍历是以树深为线索的遍历方式，所以在遍历之前需要求出树深！（递归）

实现

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:

    int getTreeDeep(TreeNode* root)
    {
        int deep=0;
        if(root)
        {
            int leftdeep = getTreeDeep(root->left);
            int rightdeep = getTreeDeep(root->right);
            deep=leftdeep>rightdeep?leftdeep+1:rightdeep+1;//取左右树深最大值
        }
        return deep;
    }
    
    void outLevelOrder(TreeNode* root,int deep,vector<vector<int> > &buf,int level)
    {
        if(root == nullptr || deep<1 )
            return ;
        if(deep == 1)
            buf[level].push_back(root->val);
        outLevelOrder(root->left,deep-1,buf,level);
        outLevelOrder(root->right,deep-1,buf,level);
    }
    
    void levelTravel(TreeNode* root,int deep,vector<vector<int> > &buf)
    {
        for(int i=1;i<=deep;i++)
        {
            outLevelOrder(root,i,buf,i-1);
        }
    }
    
    /**
     * 
     * @param root TreeNode类 
     * @return int整型vector<vector<>>
     */
    vector<vector<int> > LevelOrder(TreeNode* root) 
    {
        int deep = getTreeDeep(root);
        vector<vector<int> > levelOrder(deep);
        levelTravel(root,deep,levelOrder);
        return levelOrder;
    }
};