由一棵二叉树的先序序列和中序序列可唯一确定这棵二叉树

思路：

（1）由先序可以得到树的根节点。

（2）由中序可以得到左右子树。

（3）重复（1）（2）即可恢复

同理给出后续和中序也可以按照上述思想唯一确定一棵树（这个程序转的http://www.cnblogs.com/microgrape/archive/2011/05/12/2043932.html）

#include <iostream>
#include <map>
#include <utility>
#include <functional>
#include <string>
#include <stack>

using namespace std;

typedef char Type;

struct Node
{
     Node( Node *t ) : data( t->data ), lChild( t->lChild ), rChild( t->rChild ) {}
     Node( Type d ) : data( d ), lChild( NULL ), rChild( NULL ) {}

    struct Node* lChild;
    struct Node* rChild;
     Type data;
};

Node *rebuildFromPreInOrder( string &preOrder, string &inOrder )
{
    // preOrder and inOrder always have equal length.
    if ( preOrder.size() == 0 )
        return NULL;
    if ( preOrder.size() == 1 ) 
        return new Node( preOrder[0] );

    // get the root
     Node *root = new Node( preOrder[0] );

    // divide inOrder sequence into two sub sequences 
    // by the first node of preOrder sequence.
     size_t rootPos = inOrder.find( preOrder[0] );
    string left_sub_inorder = inOrder.substr( 0, rootPos );
    string right_sub_inorder = inOrder.substr( rootPos + 1 );
     size_t left_size = left_sub_inorder.size();
    
    // divide preOrder sequence into two sub sequences by their length.
    string left_sub_preorder = preOrder.substr( 1, left_size );
    string right_sub_preorder = preOrder.substr( left_size + 1 );

    // recursive rebuilding and connect with root
     root->lChild = rebuildFromPreInOrder( left_sub_preorder, left_sub_inorder );
     root->rChild = rebuildFromPreInOrder( right_sub_preorder, right_sub_inorder );
    return root;
}

void PostOrder( Node *root, void (*visit)(Node*) )
{
     stack<Node*> s;
     Node *cur = root;
     Node *visited = NULL;

    while( ! s.empty() || cur != NULL )
     {
        while( cur != NULL )
         {     s.push( cur ); cur = cur->lChild; }

         cur = s.top();  // check but no visit.

        if( cur->rChild == visited || cur->rChild == NULL )
         {
             visit( cur ); s.pop();
             visited = cur;
             cur = NULL; // no current node, must pop.
         }
        else
             cur = cur->rChild;
     }
}

void visit( Node *t )
{
     cout<<t->data;
}

int main()
{
    while ( !cin.eof() )
     {
        string pre, in;
         cin>>pre>>in;
         Node *root = rebuildFromPreInOrder( pre, in );
         PostOrder( root, visit );
         cout<<endl;
     }
    
    return 0;
}