【C++】二叉链表-根据先序序列和中序序列创建二叉树-判断二叉树是否同构-求树的深度

目录

1.题目

2.代码（10个样例只对了6个，并不完美）

---

1.题目

假设二叉树采用二叉链存储结构存放，设计一个递归算法判断两棵二叉树bt1和bt2是否同构。

7
1 2 3 4 5 6 7
5 8 2 6 3 2 4
3 2 5 4 6 1 7
1 2 3 4 5 6 7
5 4 8 6 3 2 2
2 1 5 4 6 3 7

Yes
4

7
1 2 3 4 5 6 7
5 8 2 3 6 2 4
3 2 5 4 6 1 7
1 2 3 4 5 6 7
5 4 8 6 3 2 2
2 1 5 4 6 3 7

No
4

2.代码（10个样例只对了6个，并不完美）

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

//树结点
typedef struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
}TreeNode,*Bitree;
int n;//树的总结点数

/*
* 判断R1、R2是否同构
* 
*       R1 : 根节点
        R2：根节点

        判断两棵树是否同构
        同构的情况：
        ① 两棵树都为空(全等)
        ② 两棵树全等
        ③ 左 / 右结点交换后全等
        两棵树都为空
*/
bool isomorphic(Bitree R1, Bitree R2) {
    
    if (R1 == NULL and R2 == NULL)
        return true;
    else if(R1 != NULL and R2 != NULL) {
        if (R1->data == R2->data) {
            if (R1->left == NULL && R2->left == NULL) // 左子树为空，右子树同构
                return isomorphic(R1->right, R2->right);

            if (R1->left != NULL && R2->left != NULL) {
                if (R1->left->data == R2->left->data)  // 两棵树全等
                return (isomorphic(R1->left, R2->left) && isomorphic(R1->right, R2->right));
                else // 交换后全等
                    return (isomorphic(R1->left, R2->right) && isomorphic(R1->right, R2->left));
            }
        }
    }
    return false;
}

/*
* 计算树的深度
*/
int getDepth(TreeNode* T) {
    if (T != NULL) {
        int lDepth = getDepth(T->left);  //左子树的深度
        int rDepth = getDepth(T->right);   //右子树的深度
        return 1 + (lDepth > rDepth ? lDepth : rDepth);   //返回左子树的深度和右子树的深度中最大值+1
    }

    return 0;
}

/*
* return 左子树的结点数
*/
int Num_leftOrRight(vector<vector<int>> Node_Data, int Node_order, int Nodeleft, int Noderight) {
    int num = 0;
    for (int j = Nodeleft; j < Noderight; j++) {
        if (Node_Data[1][Node_order] == Node_Data[2][j]) {
            num = j-Nodeleft;
            break;
        }
    }
    return num;
}


/*
* 创建树
* Node_order:当前结点在先序序列中的位置
* int Nodeleft, int Noderight:子树所有结点在中序序列中位置的左右边界
*/
Bitree BuildTree(vector<vector<int>> Node_Data, int Node_order, int Nodeleft, int Noderight) {
    
    int left_num = 0; //左子树的结点数
    int right_num = 0;
    Bitree tree = new TreeNode();
    tree->data = Node_Data[1][Node_order];//第二行为树A的先序遍历的节点的值

    //***********左子树**************
    if ((left_num = Num_leftOrRight(Node_Data, Node_order, Nodeleft, Noderight)) > 0){//有没有左子树
        tree->left = BuildTree(Node_Data, Node_order + 1, Nodeleft, Nodeleft + left_num - 1);
    }
    else {
        tree->left = NULL;
    }
    //***********右子树****************
    if ((right_num = Noderight-Nodeleft-left_num) > 0) {//有没有右子树
        tree->right = BuildTree(Node_Data, Node_order + left_num + 1, Noderight - right_num + 1, Noderight);
    }
    else {
        tree->right = NULL;
    }
    return tree;
}

vector<vector<int>> ToData(vector<vector<int>> v) {
    int temp = 0;
    for (int i = 0; i < n; i++) {
        temp = v[2][i];
        v[2][i] = v[1][temp - 1];
    }
    return v;
}

int main()
{
    //*********************读入数据****************************
    
    int temp;
    cin >> n;

    //第一行为树A的先序遍历的节点序号，第二行为树A的先序遍历的节点的值；第三行为树A的中序遍历的节点序号。
    vector<vector<vector<int>>> Node_Data;
    vector<vector<int>> ve;
    vector<int> v;
    for (int t = 0; t < 2; t++) {
        ve.clear();
        for (int i = 0; i < 3; i++) {
            v.clear();
            for (int j = 0; j < n; j++) {
                cin >> temp;
                v.push_back(temp);
            }
            ve.push_back(v);
        }
        Node_Data.push_back(ve);
    }
    Node_Data[0] = ToData(Node_Data[0]);
    Node_Data[1] = ToData(Node_Data[1]);

    //*********************由先序序列和中序序列建树*****************
    Bitree tree1 = BuildTree(Node_Data[0],0,0,n-1);
    Bitree tree2 = BuildTree(Node_Data[1],0,0,n-1);
    int depth = getDepth(tree1);
    if (isomorphic(tree1, tree2)) {
        cout << "Yes" << endl << depth << endl;
    }
    else {
        cout << "No" << endl << depth << endl;
    }
}

/*
7
1 2 3 4 5 6 7
5 8 2 6 3 2 4
3 2 5 4 6 1 7
1 2 3 4 5 6 7
5 4 8 6 3 2 2
2 1 5 4 6 3 7

*/