剑指oofer 62 - 序列化二叉树

将二叉树序列化，前序遍历，NULL指针序列化成'$'字符，及诶单之间用',' 隔开。然后根据序列化结果反序列化出二叉树。

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

struct BinaryTreeNode  
{  
    int m_nValue;  
    BinaryTreeNode* m_pLeft;  
    BinaryTreeNode* m_pRight;  
};  
BinaryTreeNode*     CreateBinaryTreeNode(int value)  
{  
    BinaryTreeNode* node = new BinaryTreeNode[sizeof(BinaryTreeNode)];  
    node->m_nValue = value;  
    node->m_pLeft = node->m_pRight    =   NULL;  
    return node;  
}    
void ConnectTreeNodes(BinaryTreeNode*   pRoot,BinaryTreeNode*   pLeft,BinaryTreeNode*   pRight)  
{  
    if(pRoot!=NULL)  
    {  
        pRoot->m_pLeft   =   pLeft;  
        pRoot->m_pRight  =   pRight;  
    }  
}  
void PrintTree(BinaryTreeNode* node)
{
	if(node!=NULL)
	{
		cout<<node->m_nValue<<" ";

		if(node->m_pLeft)
			PrintTree(node->m_pLeft);
		if(node->m_pRight)
			PrintTree(node->m_pRight);
	}
}
void DestroyTree(BinaryTreeNode* node)
{
	if(node!=NULL)
	{
		BinaryTreeNode* left = node->m_pLeft;
		BinaryTreeNode* right = node->m_pRight;

		delete node;
		node =NULL;

		DestroyTree(left);
		DestroyTree(right);
	}
}
void SerialTree(BinaryTreeNode* pRoot,ofstream &fileOut)
{
	if(pRoot==NULL)
	{
		fileOut<<"$,";
		return ;
	}
	fileOut<<pRoot->m_nValue<<",";
	SerialTree(pRoot->m_pLeft,fileOut);
	SerialTree(pRoot->m_pRight,fileOut);
}
bool ReadStream(istream &stream, int *number)
{
     if(stream.eof())
		 return false;

	char buffer[32];
    buffer[0] = '\0';

	 char ch;
	 stream>>ch;
	 int i=0;
	 while(!stream.eof()	&&	ch!=',')
	 {
		 buffer[i++]=ch;
		 stream>>ch;
	 }

	  bool isNumeric = false;
	 if(i>0 && buffer[0]!='$')  //遇到'$',返回到上一层
	 {
		 *number = atoi(buffer);
		  isNumeric = true;
		 
	 }
	 return isNumeric;

}

void DeserialTree(BinaryTreeNode** pRoot,ifstream &stream)
{
	int number;
    if(ReadStream(stream, &number))
	{
		   *pRoot = new BinaryTreeNode();  
		  (*pRoot)->m_nValue =number;  
		  (*pRoot)->m_pLeft = (*pRoot)->m_pRight    =   NULL;  

			DeserialTree(&(*pRoot)->m_pLeft ,stream);
			DeserialTree(&(*pRoot)->m_pRight ,stream);
	}
}
bool IsSame( BinaryTreeNode* pRoot1, BinaryTreeNode* pRoot2)
{
	if(pRoot1==NULL &&	 pRoot2==NULL)
		return true;
	if(pRoot1==NULL ||	 pRoot2==NULL)
		return false;
	if(pRoot1->m_nValue!=pRoot1->m_nValue)
		return false;

	return IsSame(pRoot1->m_pLeft,pRoot2->m_pLeft) && 
		 IsSame(pRoot1->m_pRight,pRoot2->m_pRight);
}
void Test(char *testName, BinaryTreeNode* pRoot)
{
	cout<<testName<<endl;
	PrintTree(pRoot);

	char *fileName= "test.txt";
	ofstream fileOut;
	fileOut.open(fileName);
	SerialTree(pRoot,fileOut);
	fileOut.close();
	cout<<endl;

	ifstream fileIn1;
	char ch;
	fileIn1.open(fileName);
	while(!fileIn1.eof())
	{		
		fileIn1>>ch;
		cout<<ch;
	}
	fileIn1.close();

	ifstream fileIn2;
	fileIn2.open(fileName);
	BinaryTreeNode* pNewRoot = NULL;
	DeserialTree(&pNewRoot ,fileIn2);
	fileIn2.close();
	cout<<endl;

	PrintTree(pNewRoot);
	cout<<endl;

	if(IsSame(pRoot,pNewRoot))
		cout<<"Passed\n\n";
	else
		cout<<"Failed\n\n";
}

	//            8
//        6      10
//       5 7    9  11
void Test1()
{
	BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);
    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode10 = CreateBinaryTreeNode(10);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7);
    BinaryTreeNode* pNode9 = CreateBinaryTreeNode(9);
    BinaryTreeNode* pNode11 = CreateBinaryTreeNode(11);

    ConnectTreeNodes(pNode8, pNode6, pNode10);
    ConnectTreeNodes(pNode6, pNode5, pNode7);
    ConnectTreeNodes(pNode10, pNode9, pNode11);

    Test("Test1", pNode8);
    DestroyTree(pNode8);
}

//            5
//          4
//        3
//      2
void Test2()
{
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);

    ConnectTreeNodes(pNode5, pNode4, NULL);
    ConnectTreeNodes(pNode4, pNode3, NULL);
    ConnectTreeNodes(pNode3, pNode2, NULL);

    Test("Test2", pNode5);

    DestroyTree(pNode5);
}

//        5
//         4
//          3
//           2
void Test3()
{
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);

    ConnectTreeNodes(pNode5, NULL, pNode4);
    ConnectTreeNodes(pNode4, NULL, pNode3);
    ConnectTreeNodes(pNode3, NULL, pNode2);

    Test("Test3", pNode5);

    DestroyTree(pNode5);
}

void Test4()
{
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);

    Test("Test4", pNode5);

    DestroyTree(pNode5);
}

void Test5()
{
    Test("Test5", NULL);
}

//        5
//         5
//          5
//         5
//        5
//       5 5
//      5   5
void Test6()
{
    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode61 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode62 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode71 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode72 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode1, NULL, pNode2);
    ConnectTreeNodes(pNode2, NULL, pNode3);
    ConnectTreeNodes(pNode3, pNode4, NULL);
    ConnectTreeNodes(pNode4, pNode5, NULL);
    ConnectTreeNodes(pNode5, pNode61, pNode62);
    ConnectTreeNodes(pNode61, pNode71, NULL);
    ConnectTreeNodes(pNode62, NULL, pNode72);

    Test("Test6", pNode1);

    DestroyTree(pNode1);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();

    return 0;
}