二叉树基础：各种遍历、深度

1.DFS

1.1 递归

    vector<int> result;
    vector<int> preorderTraversal(TreeNode* root) {
        
        if(root == nullptr)
            return result;
        
        result.push_back(root->val);//先序
        if(root->left != nullptr)
            preorderTraversal(root->left);
        //result.push_back(root->val);//中序
        if(root->right != nullptr)
            preorderTraversal(root->right);  
        //result.push_back(root->val);//后序
        
        return result;
    }

1.2 迭代

1.2.1 先序遍历

    vector<int> preorderTraversal(TreeNode* root) {

        vector<int> ret;
        stack<TreeNode*> helper;

        while(root || !helper.empty())
        {
            while(root)
            {
                ret.push_back(root->val);
                helper.push(root);
                root = root->left;
            }
            root = helper.top()
            root = root->right;
            helper.pop();
        }
        return ret;
    }

1.2.2 中序遍历

    vector<int> inorderTraversal(TreeNode* root) {

        vector<int> ret;
        stack<TreeNode*> helper;

        while(root || !helper.empty())
        {
            while(root)
            {
                helper.push(root);
                root = root->left;
            }
            root = helper.top();
            ret.push_back(root->val); 
            root = root->right;
            helper.pop();   
        }

        return ret;
    }

2.BFS

    vector<vector<int>> levelOrder(TreeNode* root) {

		vector<vector<int>> ret;
        queue<TreeNode*> q;

        if(root || !q.empty())
        {
            if(q.empty())
                q.push(root);
            while(!q.empty())
            {
                vector<int> temp;
                int size = q.size();
                for(int i = 0; i < size; i++)
                {
                    TreeNode* p = q.front();
                    if(p->left)
                        q.push(p->left);
                    if(p->right)
                        q.push(p->right);
                    temp.push_back(p->val);
                    q.pop();
                }
                ret.push_back(temp);
            }
        }
        return ret;
    }

3 例题：

3.1 深度优先遍历

110.平衡二叉树，可以套用深度优先遍历dfs模板，得到树的深度，进而进行判断

class Solution {
public:

    bool flag;
        
    int dfs(TreeNode* p)//得到子树的深度
    {
        if(p == NULL) return 0;
        int l = dfs(p->left);        
        int r = dfs(p->right);
        
        if(abs(l - r) > 1)
            flag = false;
        return max(l,r) + 1;
    }
                
    bool isBalanced(TreeNode* root) {
        if(root == NULL)
            return true;
        flag = 1;
        dfs(root);
        return flag;
 
    }
};

3.2 广度优先遍历

104. 二叉树的最大深度
     借助队列，用push和pop操作进行广度优先遍历，得到树的深度，进而求解。（深度优先遍历在很大的树时会超时失效）

class Solution {
public:
    int maxDepth(TreeNode* root) {
        
        if(root == NULL) return 0;
        queue<pair<TreeNode*,int> > que;
        que.push(make_pair(root,1));//用pair的第二位记录深度
        
        int num = 0;
        
        for(; que.size() > 0; que.pop())
        {
            auto n = que.front();
            num = max(num,n.second);
            if(n.first->left)
                que.push(make_pair(n.first->left, n.second + 1));
            if(n.first->right)
                que.push(make_pair(n.first->right, n.second + 1));
                
        }    
        return num;        
    }
};