【数据结构】树的相关算法1

1 - 最近公共祖先

剑指 Offer 68 - II. 二叉树的最近公共祖先

/**
 * 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:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
    
    
        if(!root || root == p || root == q) return root;

        auto left = lowestCommonAncestor(root->left,p,q);
        auto right = lowestCommonAncestor(root->right,p,q);

        if(!left) return right;
        if(!right) return left;
        return root;
    }
};

2 - 二叉树的遍历(重点掌握非递归算法)

144. 二叉树的前序遍历

算法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;
        dfs(root,res);
        return res;
    }

    void dfs(TreeNode* root,vector<int> &res)
    {
    
    
        if(!root) return;
        res.push_back(root->val);
        dfs(root->left,res);
        dfs(root->right,res);
    }
};

算法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> preorderTraversal(TreeNode* root) {
    
    
        vector<int> res;
        stack<TreeNode*> S;

        while(root || !S.empty()) // 模板写法
        {
    
    
            while(root){
    
    
                res.push_back(root->val);
                S.push(root);
                root = root->left;
            }
            if(!S.empty())
            {
    
    
                root = S.top();
                S.pop();
                root = root->right;
            }
        }

        return res;
    }
};

94. 二叉树的中序遍历

算法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> inorderTraversal(TreeNode* root) {
    
    
        vector<int> res;
        dfs(root,res);
        return res;
    }

    void dfs(TreeNode* root,vector<int> &res)
    {
    
    
        if(!root) return;
        dfs(root->left,res);
        res.push_back(root->val);
        dfs(root->right,res);
    }
    
};

算法2：非递归遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    
    
public:
    vector<int> inorderTraversal(TreeNode* root) {
    
    
        vector<int> res;
        stack<TreeNode*> S;
        
        while(root || !S.empty())
        {
    
    
            while(root){
    
    
                S.push(root);
                root = root->left;
            }
            if(!S.empty())
            {
    
    
                root = S.top();
                S.pop();
                res.push_back(root->val);
                root = root->right;
            }
        }

        return res;
    }
};

145. 二叉树的后序遍历

算法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> postorderTraversal(TreeNode* root) {
    
    
        vector<int> res;
        dfs(res,root);
        return res;
    }

    void dfs(vector<int> &res,TreeNode* root) // 各种遍历只是递归顺序不同
    {
    
    
        if(!root) return; // 记得递归返回
        if(root->left) dfs(res,root->left);
        if(root->right) dfs(res,root->right);
        res.push_back(root->val);
    }
};

算法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> postorderTraversal(TreeNode* root) {
    
    
        vector<int> res;
        stack<TreeNode*> S;

        while(root || !S.empty()) // 模板写法
        {
    
    
            while(root){
    
    
                res.push_back(root->val);
                S.push(root);
                root = root->right;
            }

            if(!S.empty())
            {
    
    
                root = S.top();
                S.pop();
                root = root->left;
            }
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

严格按照定义,第三次访问的时候输出

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    
    
public:
    vector<int> postorderTraversal(TreeNode* root) {
    
    
        vector<int> res;
        stack<TreeNode*> S;

        TreeNode *cur = root, *pre = NULL;
        while(cur || !S.empty())
        {
    
    
            while(cur){
    
    
                S.push(cur);
                cur = cur -> left;
            }

            cur = S.top();
            if(cur->right == NULL || cur->right == pre){
    
    
                res.push_back(cur->val);
                S.pop();
                pre = cur;
                cur = NULL;
            }else{
    
    
                cur = cur->right;
            }
        }

        return res;
    }
};

102. 二叉树的层序遍历

/**
 * 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;
        if(!root) return res; 
        queue<TreeNode*> q;
        q.push(root);

        while(q.size())
        {
    
    
            int n = q.size();
            vector<int> cur;
            while(n--)
            {
    
    
                auto t = q.front();
                q.pop();
                cur.push_back(t->val);
                if(t->left) q.push(t->left);
                if(t->right) q.push(t->right);
            }
            res.push_back(cur);
        }

        return res;
    }
};