华为OD-二叉树生成【C++】

题目

有一棵二叉树，每个节点由一个大写字母标识(最多26个节点）。现有两组字母，分别表示后序遍历（左孩子->右孩子->父节点）和中序遍历（左孩子->父节点->右孩子）的结果，请输出层次遍历的结果。

输入描述

输入为两个字符串，分别是二叉树的后续遍历和中序遍历结果。

输出描述

输出二叉树的层次遍历结果。

示例1

输入：
CBEFDA CBAEDF

输出：
ABDCEF

说明：
二叉树为：
    A
   / \
  B   D
 /   / \
C   E   F

C++代码如下：

#include <stdio.h>
#include <map>
#include <vector>
#include <iostream>
#include <string>
#include <algorithm>
#include <math.h>
using namespace std;

class TreeNode//定义二叉树
{
public:
	TreeNode* left;
	TreeNode* right;
	char val;
	TreeNode(char v)
		:val(v),left(NULL),right(NULL)
	{}
	virtual ~TreeNode()
	{
		if (left != NULL)
		{
			delete left;
			left = NULL;
		}
		if (right != NULL)
		{
			delete right;
			right = NULL;
		}
	}
	TreeNode(string Preorder,string Inorder)
		:val(0),left(NULL),right(NULL)
	{
		TreeNode* TreeRoot = constructTree(Preorder,Inorder);
		if (TreeRoot != NULL)
		{
			left = TreeRoot->left;
			right = TreeRoot->right;
			val = TreeRoot->val;
		}
		else
		{
			//无效节点
		}

	}
	TreeNode* constructTree(string Preorder,string Inorder)//根据中序和先序构建二叉树
	{
		if(Preorder.size()==0)
		{
			return NULL;
		}
		char midval = Preorder[0];
		TreeNode*root = new TreeNode(midval);
		if(Preorder.size() == 1)
		{
			return root;
		}
		int midx = 0;
		for(;midx<Preorder.size();midx++)
		{
			if(midval == Inorder[midx])
			{
				break;
			}
		}
		string pre_left = Preorder.substr(1,midx);
		string In_left = Inorder.substr(0,midx);

		if (!pre_left.empty() && !In_left.empty())
		{
			TreeNode * pLeft = new TreeNode(pre_left,In_left);
			if (pLeft->val == 0)
			{
				delete pLeft;
			}
			else
			{
				root->left = pLeft;
			}
		}
		
		string pre_right = Preorder.substr(midx+1);
		string In_right = Inorder.substr(midx+1);
		if (!pre_right.empty() && !In_right.empty())
		{
			TreeNode * pRight = new TreeNode(pre_right,In_right);

			if (pRight->val == 0)
			{
				delete pRight;
			}
			else
			{
				root->right = pRight;
			}
		}
		return root;
	}
	void LastOutPut()
	{
		lastorder(this);
		cout << endl;
	}
	void PreOutPut()
	{
		preorder(this);
		cout << endl;
	}
	void MidOutPut()
	{
		midorder(this);
		cout << endl;
	}
protected:
	void lastorder(TreeNode*Node)//输出后序遍历
	{
		if(Node == NULL)
		{
			return;
		}
		lastorder(Node->left);
		lastorder(Node->right);
		cout<<Node->val;
	}

	void preorder(TreeNode*Node)//输出前序遍历
	{
		if(Node == NULL)
		{
			return;
		}
		cout<<Node->val;
		preorder(Node->left);
		preorder(Node->right);

	}

	void midorder(TreeNode*Node)//输出中序遍历
	{
		if(Node == NULL)
		{
			return;
		}
		midorder(Node->left);
		cout<<Node->val;
		midorder(Node->right);

	}
};


int main()
{
    TreeNode* pRoot = new TreeNode("DBACEGF","ABCDEFG");
	pRoot->PreOutPut();
	pRoot->MidOutPut();
	pRoot->LastOutPut();
	delete pRoot;
    return 0;
}