牛客网－Ｃ++剑指offer－第四题(重建二叉树)

题目描述

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

 

先学习下二叉树的基础知识，以下为示例代码(二叉树的构建以及遍历):

#include <iostream>
#include <string.h>

using namespace std;

//简单二插树的创建
typedef struct tree_node{
    char data;
    tree_node *Lchild;
    tree_node *Rchild;
}LPtreenode,*LPtree_node;

//创建二叉树节点（有规律一个接着一个）
LPtree_node creat_node(char data)
{
    LPtree_node new_tree_node = new  LPtreenode;

    new_tree_node->data = data;
    new_tree_node->Lchild = NULL;
    new_tree_node->Rchild = NULL;
    return new_tree_node;
}

//无规律插入节点(参数：相对根节点，插入在该根节点的左边，插入在该根节点的右侧)
LPtree_node insert_tree_node(LPtree_node origin_node,LPtree_node lchild,LPtree_node rchild)
{
    origin_node->Lchild = lchild;
    origin_node->Rchild = rchild;
}

//前序遍历（递归） 根　左　右
LPtree_node front_print(LPtree_node origin_node)
{
    if (origin_node != NULL)
    {
        cout<<" "<<origin_node->data;
        front_print(origin_node->Lchild);
        front_print(origin_node->Rchild);
    }
}

//中序遍历（递归）左　根　右
LPtree_node middle_print(LPtree_node origin_node)
{
    if (origin_node != NULL)
    {
        middle_print(origin_node->Lchild);
        cout<<" "<<origin_node->data;
        middle_print(origin_node->Rchild);
    }
}

//后序遍历（递归）左 右 根
LPtree_node last_print(LPtree_node origin_node)
{
    if (origin_node != NULL)
    {
        last_print(origin_node->Lchild);
        last_print(origin_node->Rchild);
        cout<<" "<<origin_node->data;
    }
}

int main()
{
    //创建的节点数(死板的创建，无实际作用)
    LPtree_node A = creat_node('A');
    LPtree_node B = creat_node('B');
    LPtree_node C = creat_node('C');
    LPtree_node D = creat_node('D');
    LPtree_node E = creat_node('E');
    LPtree_node F = creat_node('F');
    LPtree_node G = creat_node('G');

    insert_tree_node(A,B,C);
    insert_tree_node(B,D,NULL);
    insert_tree_node(D,NULL,G);
    insert_tree_node(C,E,F);

    front_print(A);
    cout<<endl;
    middle_print(A);
    cout<<endl;
    last_print(A);
    cout<<endl;

    return 0;
}

 

非递归版:

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
#include <list>
#include <unordered_map>
#include <cstring>
#include <map>

using namespace std;

struct tree_node{
    int val;
    struct tree_node* left;
    struct tree_node* right;
};

//前序遍历：根　左　右
//1.一直向左走，边记录边打印
//2.找到最左边的节点
//3.出栈往右走
void front(tree_node* root)
{
    if (root == NULL)
        return;

    stack<tree_node*> my_stack;
    tree_node* pMove = root;
    while (pMove || !my_stack.empty())
    {
        while (pMove)
        {
            cout<<pMove->val<<endl;
            my_stack.push(pMove);
            pMove = pMove->left;
        }

        if (!my_stack.empty())
        {
            pMove = my_stack.top();
            my_stack.pop();
            pMove = pMove->right;
        }
    }
}

//中序遍历：左　根　右
//向左走到底
//一直入栈，找到最左边的节点，打印
//出栈往右走
void mid(tree_node* root)
{
    if (root == NULL)
        return;

    stack<tree_node*> my_stack;
    tree_node* pMove = root;

    while (pMove || !my_stack.empty())
    {
        while (pMove)
        {
            my_stack.push(pMove);
            pMove = pMove->left;
        }

        if (!my_stack.empty())
        {
            pMove = my_stack.top();
            cout<<pMove->val<<endl;
            my_stack.pop();
            pMove = pMove->right;
        }

    }
}

//后序遍历：左　右　根
//先遍历到最左边，并记录（入栈）
//判断右边节点是否为空，右边节点是否走过，如果走过就打印当前节点，并更新flag
//如果没走过，那么往右边走（入栈），在往左边走到底
//重复上面１，２，３步骤
void back(tree_node* root) {
    if (root == NULL)
        return;

    tree_node *pMove = root;
    tree_node *flag_node = NULL;
    stack<tree_node *> my_stack;

    while (pMove)
    {
        my_stack.push(pMove);
        pMove = pMove->left;
    }

    while (!my_stack.empty())
    {
        pMove = my_stack.top();
        my_stack.pop();

        if (pMove->right == NULL || pMove->right == flag_node)
        {
            cout<<pMove->val;
            flag_node = pMove;
        } else{
            my_stack.push(pMove);
            pMove = pMove->right;

            while (pMove)
            {
                my_stack.push(pMove);
                pMove = pMove->left;
            }
        }
    }
}

int main()
{
    tree_node* node1 = new tree_node;
    tree_node* node2 = new tree_node;
    tree_node* node3 = new tree_node;
    tree_node* node4 = new tree_node;
    tree_node* node5 = new tree_node;
    tree_node* node6 = new tree_node;
    tree_node* node7 = new tree_node;

    node1->val = 1;
    node1->left = node2;
    node1->right = node3;

    node2->val = 2;
    node2->left = node4;
    node2->right = node5;

    node3->val = 3;
    node3->left = node6;
    node3->right = node7;

    node4->val = 4;
    node4->left = NULL;
    node4->right = NULL;

    node5->val = 5;
    node5->left = NULL;
    node5->right = NULL;

    node6->val = 6;
    node6->left = NULL;
    node6->right = NULL;

    node7->val = 7;
    node7->left = NULL;
    node7->right = NULL;

//    front(node1);
    back(node1);

    return 0;
}

 

本题答案:

//总体思路就是找顶点，左右两边元素分离
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {

        //vector中前面元素到节点的距离
        int length;
        length = vin.size();

        //如果长度为０则返回(必须)
        if(length == 0)
        {
            return NULL;
        }

        int root;
        vector<int> pre_l_list,pre_r_list;
        vector<int> vin_l_list,vin_r_list;

        TreeNode* pmove = new TreeNode(pre[0]);

//        cout<<pmove->val<<endl;




        for(int i = 0; i < length; ++i)
        {
            if(vin[i] == pre[0])
            {
                root = i;
                cout<<root<<endl;
                break;
            }
        }

        for(int j = 0; j < root; ++j)
        {
            pre_l_list.push_back(pre[j+1]);
            vin_l_list.push_back(vin[j]);
        }

        for(int k = root+1; k < length; ++k)
        {
            pre_r_list.push_back(pre[k]);
            vin_r_list.push_back(vin[k]);
        }

        pmove->left = reConstructBinaryTree(pre_l_list,vin_l_list);
        pmove->right = reConstructBinaryTree(pre_r_list,vin_r_list);

        return pmove;
    }
};