剑指offer——已知二叉树的先序和中序排列，重构二叉树

这是剑指offer中关于二叉树重构的一道题。题目原型为：

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

一、二叉树的数据结构

---

　　做题之前，我们先熟悉下二叉树的数据结构。其一，定义：二叉树是一个连通的无环图，并且每一个顶点的度不大于3。有根二叉树还要满足根结点的度不大于2。有了根结点之后，每个顶点定义了唯一的父结点，和最多2个子结点。然而，没有足够的信息来区分左结点和右结点。如果不考虑连通性，允许图中有多个连通分量，这样的结构叫做森林。（定义来自百度百科）

　　由定义可知，二叉树含有许多节点，而不同节点之间通过子父关系来连接。一般来说，二叉树的节点由结构体来定义，如下所示：　

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
    ~TreeNode() {
        cout << "TreeNode with value " << val << " has been destroyed." <<endl;
    }
};

　　该结构体定义了节点的int型变量（当然也可以是其它类型），以及指向左右孩子的指针。在TreeNode中，我们还定义了构造函数和析构函数，其实可有可无，对本题来说没有多大意义。

二、二叉树的建立

---

　　二叉树的建立过程，就是不断扩展节点的过程。建立根节点，由根节点建立左右子节点，再递归的建立子节点的子节点。我们下面看看代码的实现过程：

void BiTree::createBiTree(struct TreeNode* &root) {
    int val;
    //cout << "Please input the tree node:" << endl;
    cin >> val;
    if (999 == val) {
        root = NULL;
    }
    else {
        //root = (struct TreeNode*) malloc(sizeof(TreeNode));
        root = new TreeNode(1);
        if (root == NULL)
            return;
        root->val = val;

        cout << "Please input the left child of " << val << ": ";
        createBiTree(root->left);

        cout << "Please input the right child of" << val << ": ";
        createBiTree(root->right);
    }
}

　　这里，我是把创建二叉树的方法createBiTree()作为了BiTree的成员函数（简单说明一下）。

　　1、首先，我们看参数 struct TreeNode* &root， 这是结构体指针的引用。为什么要传递引用呢，就是希望函数体外的指针变量能指向函数体内所新建的根节点。若只是指针传递，那么函数体内新建的节点和函数体外的指针变量是没有指向关系的。

　　2、然后就是新建节点，

　　//root = (struct TreeNode*) malloc(sizeof(TreeNode));
     root = new TreeNode(1);
　　这两条语句的效果相同。如果创建成功，那么递归调用本方法，创建后续节点。

三、二叉树的遍历

---

　　二叉树有三种遍历方法：先序，中序，后序。即父前（父-左-右），父中（左-父-右），父后（左-右-父）。
　　
　　1、先序遍历

// 这里参数传递指针，或指针的引用都可以
void BiTree::preOrder(struct TreeNode* &root) {
    if (root == NULL)
        return;
    cout << root->val << ' ';
    preTrav.push_back(root->val);
    preOrder(root->left);
    preOrder(root->right);
}

　　其中，preTraa.push_back(root->val);我只是把先序遍历的结果存在了vector 中，方便重构二叉树时作为输入。下同。

　　2,、中序遍历

void BiTree::inOrder(struct TreeNode* root) {
    if (root == NULL)
        return;
    inOrder(root->left);
    cout << root->val << ' ';
    inTrav.push_back(root->val);
    inOrder(root->right);
}

　　3、后序遍历，就不贴代码了。

　　另外，值得说明一下的是。这里的遍历方法都是通过递归来实现的，还有遍历的非递归算法（日后再详细去探讨，这里先着重看这个题目，也不知日后是否会想起这个任务。。。囧）

三、已知先序遍历，中序遍历，重构二叉树

---

　　我们观察先序遍历和中序遍历的结果。先序遍历的第一个节点肯定是根节点，然后在中序遍历中找到此根节点，我们可以看到，中序遍历中根节点以左是二叉树的左子树，根节点以右是二叉树的右子树。然后，左右子女树又可以单独的看成一个独立的二叉树，然后再对其划分，如此递归，便可重构二叉树的结构。下面上代码：

struct TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> in){
        //TreeNode* head = new TreeNode(pre[0]);
        /* 注意上面这一条语句不能放在函数体的第一句。
         * 因为此时还不能确定pre这个vector是否为空，如果不为空，那么访问pre[0]就是非法内存访问。此时若debug，会有
         * Program received signal SIGSEGV, Segmentation fault.的错误信息。其中，SIG是signal的缩写，SEGV是segmentation violation（段违例）的缩写。详见维基百科
         * 所以，此条语句放在return NULL；语句之后为宜，因为这个时候已经确定vector in不为空。但是好像没判断pre是否为空呢，这就可以了？？
        */
        vector<int> left_pre, left_in, right_pre, right_in;

        int pos = 0;
        int length = in.size();

        if (length == 0)
            return NULL;

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

        for (int i = 0; i < length; ++i) {
            if (pre[0] == in[i]) {
                pos = i;
                break;
            }
        }

        for (int i = 1; i < pos + 1; ++i) {
            left_pre.push_back(pre[i]);
            left_in.push_back(in[i-1]);
        }

        for (int i = pos + 1; i < length; ++i) {
            right_pre.push_back(pre[i]);
            right_in.push_back(in[i]);
        }

        head->left = reConstructBinaryTree(left_pre, left_in);
        head->right = reConstructBinaryTree(right_pre, right_in);

        return head;

    }

　　其实，关于这个重构函数，笔者还有一个问题，就如函数中注释中所诉。还请广大博友解答下（新手博客，都没人看，好忧伤~_~!）

四、重构验证

---

　　首先，贴上验证程序。验证程序综合了上述建立二叉树，遍历二叉树以及重构二叉树的相关实现。

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

// Definition for binary tree
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
    ~TreeNode() {
        cout << "TreeNode with value " << val << " has been destroyed." <<endl;
    }
};

class BiTree {
public:
    int flag;
    vector<int> preTrav, inTrav;

    BiTree(int _flag) : flag(_flag){
        cout << "Instance of Bitree with flag " << flag << " has been constructed." << endl;
    }
    ~BiTree() {
        cout << "Instance of Bitree with flag " << flag << " has been destroyed." << endl;
    }

    /* createBiTree()注意这里传递的是指针的引用，因为函数体内部在不断的new，需要让传进来的根节点指向内部新开辟的空间，
     * 不过这样的话，在main函数内，定义的mytree结构体的空间就浪费了，怎么去优化呢？
     * struct TreeNode* tree = nullptr;此条语句解决上诉问题
    */
    void createBiTree(struct TreeNode*&);
    void preOrder(struct TreeNode*&);   //这里传递指针或指针的引用都可以
    void inOrder(struct TreeNode*);
};
// Create the binary tree
void BiTree::createBiTree(struct TreeNode* &root) {
    int val;
    //cout << "Please input the tree node:" << endl;
    cin >> val;
    if (999 == val) {
        root = NULL;
    }
    else {
        //root = (struct TreeNode*) malloc(sizeof(TreeNode));
        root = new TreeNode(1);
        if (root == NULL)
            return;
        root->val = val;

        cout << "Please input the left child of " << val << ": ";
        createBiTree(root->left);

        cout << "Please input the right child of" << val << ": ";
        createBiTree(root->right);
    }
}

// pre order of binary tree
void BiTree::preOrder(struct TreeNode* &root) {
    if (root == NULL)
        return;
    cout << root->val << ' ';
    preTrav.push_back(root->val);
    preOrder(root->left);
    preOrder(root->right);
}

// in order of binary tree
void BiTree::inOrder(struct TreeNode* root) {
    if (root == NULL)
        return;
    inOrder(root->left);
    cout << root->val << ' ';
    inTrav.push_back(root->val);
    inOrder(root->right);
}
// 在类外部定义一个中序遍历，作调试用
void inOrder(struct TreeNode* &root) {
    if (root == NULL)
        return;
    inOrder(root->left);
    cout << root->val << ' ';
    inOrder(root->right);
}

// Solution of reconstruct binary tree
class Soultion {
public:
    int flag;
    Soultion(int _flag) : flag(_flag) {
        cout << "Instance of Solution with flag " << flag << " has been constructed." << endl;
    }
    ~Soultion() {
        cout << "Instance of Solution with flag " << flag << " has been destroyed." << endl;
    }

    struct TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> in){
        //TreeNode* head = new TreeNode(pre[0]);
        /* 注意上面这一条语句不能放在函数体的第一句。
         * 因为此时还不能确定pre这个vector是否为空，如果不为空，那么访问pre[0]就是非法内存访问。此时若debug，会有
         * Program received signal SIGSEGV, Segmentation fault.的错误信息。其中，SIG是signal的缩写，SEGV是segmentation violation（段违例）的缩写。详见维基百科
         * 所以，此条语句放在return NULL；语句之后为宜，因为这个时候已经确定vector in不为空。但是好像没判断pre是否为空呢，这就可以了？？
        */
        vector<int> left_pre, left_in, right_pre, right_in;

        int pos = 0;
        int length = in.size();

        if (length == 0)
            return NULL;

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

        for (int i = 0; i < length; ++i) {
            if (pre[0] == in[i]) {
                pos = i;
                break;
            }
        }

        for (int i = 1; i < pos + 1; ++i) {
            left_pre.push_back(pre[i]);
            left_in.push_back(in[i-1]);
        }

        for (int i = pos + 1; i < length; ++i) {
            right_pre.push_back(pre[i]);
            right_in.push_back(in[i]);
        }

        head->left = reConstructBinaryTree(left_pre, left_in);
        head->right = reConstructBinaryTree(right_pre, right_in);

        return head;

    }
    // 在solution类中也定义个中序遍历，作调试用
    void inOrder(struct TreeNode* &root) {
        if (root == NULL)
            return;
        inOrder(root->left);
        cout << root->val << ' ';
        inOrder(root->right);
    }

};

int main() {
    //struct TreeNode myTree(1);
    //struct TreeNode* tree = &myTree;
    struct TreeNode* tree = nullptr;

    BiTree myBiTree(1);
    cout << "Please input the head tree node: ";
    myBiTree.createBiTree(tree);

    cout << "Preorder of binary tree." << endl;
    myBiTree.preOrder(tree);

    cout << endl << "Inorder of binary tree." << endl;
    myBiTree.inOrder(tree);
    cout << endl;

    Soultion mySolution(2);
    cout << endl
         << "refactor the binary tree based on preorder and inorder
"
         << "and print it with preorder"
         << endl;
    myBiTree.inOrder(mySolution.reConstructBinaryTree(myBiTree.preTrav, myBiTree.inTrav));
    cout << endl;

    delete tree;
    //struct TreeNode* refactor = mySolution.reConstructBinaryTree(myBiTree.preTrav, myBiTree.inTrav);
    //myBiTree.inOrder(refactor);
    //mySolution.inOrder(refactor);

    //inOrder(refactor);
    return 0;
}

　　下面我们看看程序结果。

从结果中我们可以看见，重构后二叉树的中序遍历和我们输入的二叉树的中序遍历相同。我们还可以输出重构后的先序遍历，来确定我们的重构是正确的。
二叉树的重构暂且先探讨这。二叉树还有其它很多特性需要没我们去研究，择日再说。