力扣：二叉树：节点最近公共祖先

菜鸟程序员纪念一下，第一次完整写的acm题目

题目思路不难就是构建二叉树还有验证好麻烦wuwu（可能main函数处理的复杂了）

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

struct Treenode{
    int val;
    Treenode *left, *right;
    Treenode(): val(0), left(nullptr), right(nullptr){};
    Treenode(int val): val(val), left(nullptr), right(nullptr){};
    Treenode(int val, Treenode *left, Treenode *right): val(val), left(left), right(right){};
};

class Solution{
public:
    Treenode* travsal(Treenode *cur, Treenode *p,Treenode *q){
        if(cur==nullptr||cur==p||cur==q){
            return cur;
        }
        Treenode *left = travsal(cur->left, p, q);
        Treenode *right = travsal(cur->right, p, q);

        if(left!=nullptr&&right!=nullptr) return cur;
        
        return left?left:right;
    }

    Treenode *findM(Treenode *root, Treenode *p,Treenode *q){
        return  travsal(root, p, q);

    }


    Treenode* find(Treenode* root, int val){
        if(root==nullptr) return nullptr;
        if(root->val==val) return root;
        Treenode* leftresult = find(root->left, val);
        if(leftresult!=nullptr) return leftresult;
        return find(root->right, val);
    }

    Treenode* Final(Treenode* root, int val1, int val2){
        if(root==nullptr) return nullptr;
        Treenode *node1 = find(root, val1);
        Treenode *node2 = find(root, val2);
        return findM(root, node1, node2);
    }

};
// 用于测试的打印函数
void printInOrder(Treenode* node) {
    if (node == nullptr) {
        return;
    }
    printInOrder(node->left);
    std::cout << node->val << " ";
    printInOrder(node->right);
}

Treenode* constract_tree(const vector<int>& nums){
    if(nums.empty()) return nullptr;
    Treenode *root = new Treenode(nums[0]);
    int i =1;
    queue<Treenode*> q;
    q.push(root);
   
    while(!q.empty()&&i<nums.size()){
        Treenode *cur = q.front();  //队列的用途就在于每次走完两个节点下次就可以将头部节点的左右节点位置找到
        q.pop();
        if(nums[i]!=-1){
            cur->left = new Treenode(nums[i]);
            q.push(cur->left);
        }
        i++;
        if(nums[i]!=-1){
            cur->right = new Treenode(nums[i]);
            q.push(cur->right);
        }
        i++;
    }
    return root;
}


void deleteTree(Treenode* root) {
    if (root == nullptr) return;
    deleteTree(root->left);
    deleteTree(root->right);
    delete root;
}

int main(){
    int n;
    cout<<"输入层序遍历二叉树数组大小：";
    cin>>n;

    vector<int> nums(n);
    cout << "输入层序遍历二叉树数组（-1表示空节点):";
    for (int i = 0; i < n; ++i) {
        cin >> nums[i];
    }
    Treenode* root = constract_tree(nums);
    
    cout<<"构建的二叉树的中序遍历为：";
    printInOrder(root);

    //输入你要查找祖先的节点

    int val1, val2;
    cout << "输入你要查找祖先的节点: ";
    cin >> val1 >> val2;

    Solution sol;
    Treenode* p = sol.Final(root, val1, val2);

    // Output result
    if (p != nullptr) {
        cout << "The lowest common ancestor of " << val1 << " and " << val2 << " is " << p->val << "." << endl;
    } else {
        cout << "No common ancestor found." << endl;
    }

    delete p;

    deleteTree(root);

    return 0;
}