重建二叉树

昨天看书，看到二叉树相关问题，之前都没有认真看二叉树，导致碰见前序、中序、后序遍历这些问题比较头大。今天认真的研究了一下，发现也就那么回事。

自己写的根据前序、中序排列重建二叉树并将二叉树用三种遍历方式打印出来。

// PrintBinaryTree.cpp: 定义控制台应用程序的入口点。
//

/*

Author:wyl
QQ:635864540
Date:20180323

*/
#include "stdafx.h"

#include <vector>

using namespace std;

struct TreeNode
{
	TreeNode *left;
	TreeNode *right;
	int val;

	TreeNode(int x = 0) {
		val = x;
		left = NULL;
		right = NULL;
	}
};

struct strTreeNode
{
	strTreeNode *left;
	strTreeNode *right;
	char val;

	strTreeNode(char x = '0') {
		val = x;
		left = NULL;
		right = NULL;
	}
};

void PreHeadPrintTree(TreeNode *root)
{
	if (root == NULL)
		return;
	printf("%d ", root->val);
	PreHeadPrintTree(root->left);
	PreHeadPrintTree(root->right);
}

void InnerPrintTree(TreeNode *root)
{
	if (root == NULL)
		return;
	InnerPrintTree(root->left);
	printf("%d ", root->val);
	InnerPrintTree(root->right);
}

void BackendPrintTree(TreeNode *root)
{
	if (root == NULL)
		return;
	BackendPrintTree(root->left);
	BackendPrintTree(root->right);
	printf("%d ", root->val);
}

void PreHeadPrintTree(strTreeNode *root)
{
	if (root == NULL)
		return;
	printf("%c ", root->val);
	PreHeadPrintTree(root->left);
	PreHeadPrintTree(root->right);
}

void InnerPrintTree(strTreeNode *root)
{
	if (root == NULL)
		return;
	InnerPrintTree(root->left);
	printf("%c ", root->val);
	InnerPrintTree(root->right);
}

void BackendPrintTree(strTreeNode *root)
{
	if (root == NULL)
		return;
	BackendPrintTree(root->left);
	BackendPrintTree(root->right);
	printf("%c ", root->val);
}

void ReConstructTree(string preStr, string innerStr, TreeNode **root)
{
	if (preStr.length() == 1)
	{
		*root = new TreeNode(0 + (preStr[0] - '0'));
		return;
	}
	else if (preStr.length() == 2)
	{
		*root = new TreeNode(0 + (preStr[0] - '0'));
		if (preStr.compare(innerStr.c_str()) == 0)
		{
			TreeNode *rightNode = new TreeNode(0 + (preStr[1] - '0'));
			(*root)->right = rightNode;
			return;
		}
		else
		{
			TreeNode *leftNode = new TreeNode(0 + (preStr[1] - '0'));
			(*root)->left = leftNode;
			return;
		}
	}
	else
	{
		//only has right node
		if (preStr[0] == innerStr[0])
		{
			*root = new TreeNode(0 + (preStr[0] - '0'));
			ReConstructTree(preStr.substr(1, preStr.length() - 1), innerStr.substr(1, innerStr.length() - 1), &((*root)->right));
		}
		//only has left node
		else if (preStr[0] == innerStr[innerStr.length() - 1])
		{
			*root = new TreeNode(0 + (preStr[0] - '0'));
			ReConstructTree(preStr.substr(1, preStr.length() - 1), innerStr.substr(0, innerStr.length() - 1), &((*root)->left));
		}
		else
		{
			*root = new TreeNode(0 + (preStr[0] - '0'));
			//left node str
			string leftPreStr = preStr.substr(1, innerStr.find(preStr[0]));
			string leftInnerStr = innerStr.substr(0, innerStr.find(preStr[0]));

			ReConstructTree(leftPreStr, leftInnerStr, &((*root)->left));
			//right node str
			string rightPreStr = preStr.substr(innerStr.find(preStr[0]) + 1);
			string rightInnerStr = innerStr.substr(innerStr.find(preStr[0]) + 1);
			ReConstructTree(rightPreStr, rightInnerStr, &((*root)->right));
		}
	}
}

void ReConstructTree(vector<int>& preVec, vector<int>& innerVec, TreeNode **root)
{
	if (preVec.size() == 1)
	{
		*root = new TreeNode(preVec[0]);
		return;
	}
	else if (preVec.size() == 2)
	{
		*root = new TreeNode(preVec[0]);
		if (preVec[0] == innerVec[0] && preVec[1] == innerVec[1])
		{
			TreeNode *rightNode = new TreeNode(preVec[1]);
			(*root)->right = rightNode;
			return;
		}
		else
		{
			TreeNode *leftNode = new TreeNode(preVec[1]);
			(*root)->left = leftNode;
			return;
		}
	}
	else
	{
		//only has right node
		if (preVec[0] == innerVec[0])
		{
			*root = new TreeNode(preVec[0]);
			vector<int> newPreVec(preVec.begin() + 1, preVec.end());
			vector<int> newInnerVec(innerVec.begin()+1, innerVec.end());
			ReConstructTree(newPreVec, newInnerVec, &((*root)->right));
		}
		//only has left node
		else if (preVec[0] == innerVec[innerVec.size() - 1])
		{
			*root = new TreeNode(preVec[0]);
			vector<int> newPreVec(preVec.begin()+1, preVec.end());
			vector<int> newInnerVec(innerVec.begin(), innerVec.end()-1);
			ReConstructTree(newPreVec, newInnerVec, &((*root)->left));
		}
		else
		{
			*root = new TreeNode(preVec[0]);
			//left node str
			vector<int> leftPreVec;
			vector<int> leftInnerVec;
			int index = 1;
			for (vector<int>::iterator itor = innerVec.begin(); *itor != preVec[0]; ++itor)
			{
				leftPreVec.push_back(preVec[index++]);
				leftInnerVec.push_back(*itor);
			}
			ReConstructTree(leftPreVec, leftInnerVec, &((*root)->left));

			//right node str
			vector<int> rightPreVec;
			vector<int> rightInnerVec;
			vector<int>::iterator preVecItor = preVec.begin();
			vector<int>::iterator innerVecItor = innerVec.begin();
			while (*innerVecItor != preVec[0])
			{
				++innerVecItor;
				++preVecItor;
			}
			++innerVecItor;
			++preVecItor;
			for (; preVecItor != preVec.end(); ++preVecItor)
			{
				rightPreVec.push_back(*preVecItor);
				rightInnerVec.push_back(*innerVecItor);
				++innerVecItor;
			}

			ReConstructTree(rightPreVec, rightInnerVec, &((*root)->right));
		}
	}
}

void strReConstructTree(string preStr, string innerStr, strTreeNode **root)
{
	if (preStr.length() == 1)
	{
		*root = new strTreeNode(preStr[0]);
		return;
	}
	else if (preStr.length() == 2)
	{
		*root = new strTreeNode(preStr[0]);
		if (preStr.compare(innerStr.c_str()) == 0)
		{
			strTreeNode *rightNode = new strTreeNode(preStr[1]);
			(*root)->right = rightNode;
			return;
		}
		else
		{
			strTreeNode *leftNode = new strTreeNode(preStr[1]);
			(*root)->left = leftNode;
			return;
		}
	}
	else
	{
		//only has right node
		if (preStr[0] == innerStr[0])
		{
			*root = new strTreeNode(preStr[0]);
			strReConstructTree(preStr.substr(1, preStr.length() - 1), innerStr.substr(1, innerStr.length() - 1), &((*root)->right));
		}
		//only has left node
		else if (preStr[0] == innerStr[innerStr.length() - 1])
		{
			*root = new strTreeNode(preStr[0]);
			strReConstructTree(preStr.substr(1, preStr.length() - 1), innerStr.substr(0, innerStr.length() - 1), &((*root)->left));
		}
		else
		{
			*root = new strTreeNode(preStr[0]);
			//left node str
			string leftPreStr = preStr.substr(1, innerStr.find(preStr[0]));
			string leftInnerStr = innerStr.substr(0, innerStr.find(preStr[0]));

			strReConstructTree(leftPreStr, leftInnerStr, &((*root)->left));
			//right node str
			string rightPreStr = preStr.substr(innerStr.find(preStr[0]) + 1);
			string rightInnerStr = innerStr.substr(innerStr.find(preStr[0]) + 1);
			strReConstructTree(rightPreStr, rightInnerStr, &((*root)->right));
		}
	}
}

int main()
{
	TreeNode *root = new TreeNode(1);
	TreeNode *left1 = new TreeNode(2);
	TreeNode *left2 = new TreeNode(4);
	TreeNode *left2Right = new TreeNode(7);
	root->left = left1;
	left1->left = left2;
	left2->right = left2Right;

	TreeNode *right1 = new TreeNode(3);
	TreeNode *right1Left = new TreeNode(5);
	TreeNode *right1Right = new TreeNode(6);
	TreeNode *right1RightRight = new TreeNode(8);
	root->right = right1;
	right1->left = right1Left;
	right1->right = right1Right;
	right1Right->right = right1RightRight;

	PreHeadPrintTree(root);
	printf("\n");
	InnerPrintTree(root);
	printf("\n");
	BackendPrintTree(root);
	printf("\n");

	printf("=========================\n");
	TreeNode *newRoot = NULL;
	ReConstructTree("4213576", "1234567", &newRoot);
	PreHeadPrintTree(newRoot);
	printf("\n");
	InnerPrintTree(newRoot);
	printf("\n");
	BackendPrintTree(newRoot);
	printf("\n");
	printf("=========================\n");

	TreeNode *secRoot = NULL;
	int a[] = { 5,3,2,4,8,6,10 };
	int b[] = { 2,3,4,5,6,8,10 };
	vector<int> preOrder;
	for (int i = 0; i < sizeof(a)/4; ++i)
		preOrder.push_back(a[i]);
	vector<int> inOrder;
	for (int i = 0; i < sizeof(b)/4; ++i)
		inOrder.push_back(b[i]);
	ReConstructTree(preOrder, inOrder, &secRoot);
	PreHeadPrintTree(secRoot);
	printf("\n");
	InnerPrintTree(secRoot);
	printf("\n");
	BackendPrintTree(secRoot);
	printf("\n");
	printf("=========================\n");

	string str1 = "BEXLMKCPDHQA";
	string str2 = "LXMECKPBQHDA";
	strTreeNode *strTreeRoot = NULL;
	strReConstructTree(str1, str2, &strTreeRoot);
	PreHeadPrintTree(strTreeRoot);
	printf("\n");
	InnerPrintTree(strTreeRoot);
	printf("\n");
	BackendPrintTree(strTreeRoot);
	printf("\n");

	system("pause");
    return 0;
}