重建二叉树

题目

　　输入某二叉树的前序遍历和中序遍历，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含有重复的数字。

　　例如，前序遍历序列：｛1，2，3，7，3，5，6，8｝，中序遍历序列：｛4，7，2，1，5，3，8，6｝

答案

　　前序遍历：

　　　　前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树。

　　中序遍历：

　　　　中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。在遍历左、右子树时，仍然先遍历左子树，再访问根结点，最后遍历右子树。

　

#include "stdafx.h"
#include<deque>
#include<iostream>
#define TREElEN 6

struct BinaryTreeNode
{
    int                   m_nValue;
    BinaryTreeNode*       m_pLeft;
    BinaryTreeNode*       m_pRight;
};

void PrintTreeNode(BinaryTreeNode* pNode)
{
    if(pNode != NULL)
    {
        printf("value of this node is: %c
", pNode->m_nValue);

        if(pNode->m_pLeft != NULL)
            printf("value of its left child is: %c.
", pNode->m_pLeft->m_nValue);
        else
            printf("left child is null.
");

        if(pNode->m_pRight != NULL)
            printf("value of its right child is: %c
", pNode->m_pRight->m_nValue);
        else
            printf("right child is null
");
    }
    printf("
");
}

void PrintTree(BinaryTreeNode* pRoot)
{
    PrintTreeNode(pRoot);

    if(pRoot != NULL)
    {
        if(pRoot->m_pLeft != NULL)
            PrintTree(pRoot->m_pLeft);

        if(pRoot->m_pRight != NULL)
            PrintTree(pRoot->m_pRight);
    }
}

BinaryTreeNode* rebuild(char *preOrder, char* inOrder, int length)
{
    if(preOrder == NULL || inOrder == NULL || length <= 0)
        return NULL;

    char c = preOrder[0];

    BinaryTreeNode* root = new BinaryTreeNode();
    root->m_nValue = c;
    root->m_pRight = root->m_pLeft = NULL;

    int i ;
    for(i = 0 ; i < length && inOrder[i] != c ; i++);
    int leftLength = i;
    int rightLength = length - i - 1;

    if(leftLength > 0)
            root->m_pLeft = rebuild(&preOrder[1],&inOrder[0],leftLength);

    if(rightLength>0)
            root->m_pRight = rebuild(&preOrder[leftLength + 1], &inOrder[leftLength+1], rightLength);
    return root;
}

void PrintFromTopToBottom(BinaryTreeNode* pRoot)
{
    if(pRoot == NULL)
        return;

    std::deque<BinaryTreeNode *> dequeTreeNode;

    dequeTreeNode.push_back(pRoot);

    while(dequeTreeNode.size())
    {
        BinaryTreeNode *pNode = dequeTreeNode.front();
        dequeTreeNode.pop_front();

        printf("%c ", pNode->m_nValue);

        if(pNode->m_pLeft)
            dequeTreeNode.push_back(pNode->m_pLeft);

        if(pNode->m_pRight)
            dequeTreeNode.push_back(pNode->m_pRight);
    }
}
// 普通二叉树
//              a
//           /     
//          b       c  
//         /       / 
//        d       e   f
int main()
{
    char PreOrder[TREElEN] = {'a', 'b', 'd', 'c', 'e', 'f'};
    char InOrder[TREElEN] =  {'d', 'b', 'a', 'e', 'c', 'f'};
    BinaryTreeNode* result = rebuild(PreOrder, InOrder, 6);
    PrintFromTopToBottom(result);
    printf("

");
    PrintTree(result);
}