Leetcode 最小公共祖先

最小公共祖先

算法描述

在二叉树中求指定两个节点的最小公共祖先

输入: TreeNode* root, p, q;

输出: LCA

题目地址： https://leetcode.com/explore/learn/card/data-structure-tree/133/conclusion/932/

参考思路: https://leetcode.com/explore/learn/card/data-structure-tree/133/conclusion/932/discuss/132926/easy-to-understand-c++-iterative-version

算法思路

首先构建如下结构体存储所需要的信息

struct Frame {
    TreeNode *node;     // 当前节点
    Frame    *parent;   // 当前节点的父节点
    TreeNode *result;   // 目标节点，输出值
}

在求解过程中，需要知道当前节点以及其父节点，并记录可能的最小公共父节点。首先构建树的后序遍历序列ret，以Frame结构为该序列的元素。构建过程中，若当前节点是p或者q，则result域置为当前节点，否则置空。因为result域存的是可能的最小公共节点，在初始化时我们认为p或者q所在节点为可能的最小公共节点的候选。

构建完ret之后，顺序遍历ret，对每个节点进行判断，若当前节点的result域为空则跳过。否则，判断其父节点result域是否为空。

若为空，则将父节点result域置为当前节点的result。若不为空，则表示父节点可能是两个节点的公共节点，则将父节点的result域置为父节点。

这样逐级传递，即可找到最小公共父节点。

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

struct Frame {
    TreeNode *node;
    Frame *parent;
    TreeNode *result;
    Frame(TreeNode *node, Frame *parent):node(node),parent(parent),result(NULL){}
};
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root) return NULL;
        vector<Frame*> ret;
        // 后序遍历
        stack<Frame*> s;
        if(root) s.push(new Frame(root, NULL));
        while(!s.empty()){
            Frame * frame = s.top();
            s.pop();
            ret.insert(ret.begin(), frame);
            if(frame->node==p || frame->node==q){
                frame->result = frame->node;
            }
            if(frame->node->left) s.push(new Frame(frame->node->left, frame));
            if(frame->node->right) s.push(new Frame(frame->node->right, frame));
        }
        // 寻找候选LCA
        for(int i=0;i<ret.size()-1;i++){
            if(ret[i]->result){
                if(ret[i]->parent->result && ret[i]->parent->result!=ret[i]->result){
                    ret[i]->parent->result = ret[i]->parent->node;
                } else {
                    ret[i]->parent->result = ret[i]->result;
                }
            }
        }
        return ret.back()->result;
    }
};