合并二叉树、拷贝二叉树

题目：已知任意两颗二叉树tree1,tree2,合并为一个新的二叉树。重叠的节点值叠加，非叠加的节点，直接作为新树的节点

 

            tree1
			  1
			/   \
		   2     3
          /
		 4

                            ---------\                        6(1+5)
                            ---------/                       / \
                                                            8   10
           tree2                                           /    /
			5                                             4    8
		  /   \                                        
		 6     7
		      /
			 8


struct TreeNode
{
	int nValue;
	TreeNode* pLeft;
	TreeNode* pRight;

	void init(int value)
	{
		nValue = value;
		pLeft = nullptr;
		pRight = nullptr;
	}
};

一、递归方案

// 递归合并树
TreeNode* treeMerge(TreeNode *treeOne, TreeNode *treeTwo)
{
	if (treeOne == nullptr)
	{
		return treeTwo;
	}
	if (treeTwo == nullptr)
	{
		return treeOne;
	}
	TreeNode* newTree = (TreeNode*)malloc(sizeof(struct TreeNode));
	newTree->init(treeOne->nValue + treeTwo->nValue);
	newTree->pLeft = treeMerge(treeOne->pLeft, treeTwo->pLeft);
	newTree->pRight = treeMerge(treeOne->pRight, treeTwo->pRight);

	return newTree;
}

// 递归拷贝树
TreeNode* copyTree(TreeNode *pTree)
{
	if (pTree == nullptr)
	{
		return nullptr;
	}

	TreeNode* newTree = (TreeNode*)malloc(sizeof(struct TreeNode));
	newTree->init(pTree->nValue);

	newTree->pLeft = copyTree(pTree->pLeft);
	newTree->pRight = copyTree(pTree->pRight);

	return newTree;
}

二、非递归拷贝树--逻辑就是  广度遍历

// 非递归
TreeNode *treeMerge2(TreeNode *treeOne, TreeNode *treeTwo)
{
	if (treeOne == nullptr) 
	{
		return treeTwo;
	}

	if (treeTwo == nullptr) 
	{
		return treeOne;
	}
	TreeNode* newTree = (TreeNode*)malloc(sizeof(struct TreeNode));
	newTree->init(treeOne->nValue + treeTwo->nValue);


	queue<TreeNode*> q;
	queue<TreeNode*> queue1;
	queue<TreeNode*> queue2;

	q.push(newTree);
	queue1.push(treeOne);
	queue2.push(treeTwo);

	while (!queue1.empty() && !queue2.empty())
	{
		TreeNode* node = q.front();
		TreeNode* node1 = queue1.front();
		TreeNode* node2 = queue2.front();

		q.pop();
		queue1.pop();
		queue2.pop();

		TreeNode* left1 = node1->pLeft;
		TreeNode* left2 = node2->pLeft;
		TreeNode* right1 = node1->pRight;
		TreeNode* right2 = node2->pRight;

		if (left1 != nullptr || left2 != nullptr)
		{
			if (left1 != nullptr && left2 != nullptr)
			{
				TreeNode* left = (TreeNode*)malloc(sizeof(struct TreeNode));
				left->init(left1->nValue + left2->nValue);

				node->pLeft = left;
				q.push(left);
				queue1.push(left1);
				queue2.push(left2);
			}
			else if (left1 != nullptr)
			{
				node->pLeft = copyTree2(left1);
			}
			else if (left2 != nullptr)
			{
				node->pLeft = copyTree2(left2);
			}
		}
		if (right1 != nullptr || right2 != nullptr)
		{
			if (right1 != nullptr && right2 != nullptr)
			{
				TreeNode* right = (TreeNode*)malloc(sizeof(struct TreeNode));
				right->init(right1->nValue + right2->nValue);

				node->pRight = right;
				q.push(right);
				queue1.push(right1);
				queue2.push(right2);
			}
			else if (right1 != nullptr)
			{
				node->pRight = copyTree2(right1);
			}
			else
			{
				node->pRight = copyTree2(right2);
			}
		}
	}

	return newTree;
}

// 非递归拷贝树
TreeNode *copyTree2(TreeNode *pTree)
{
	if (pTree == nullptr)
	{
		return nullptr;
	}
	TreeNode* pTempLeft = nullptr;
	TreeNode* pTempRight = nullptr;

	TreeNode* newTree = (TreeNode*)malloc(sizeof(struct TreeNode));
	newTree->init(pTree->nValue);

	queue<TreeNode*> treeQueue;
	treeQueue.push(pTree);

	queue<TreeNode*> copyQueue;
	copyQueue.push(newTree);

	while (!treeQueue.empty())
	{
		TreeNode* node1 = treeQueue.front();
		treeQueue.pop();

		TreeNode* copyNode = copyQueue.front();
		copyQueue.pop();

		if (node1->pLeft != nullptr)
		{
			treeQueue.push(node1->pLeft);

			// 构造左节点
			copyNode->pLeft = (TreeNode*)malloc(sizeof(struct TreeNode));
			copyNode->pLeft->init(node1->pLeft->nValue);

			copyQueue.push(copyNode->pLeft);
		}

		if (node1->pRight != nullptr)
		{
			treeQueue.push(node1->pRight);

			// 构造右节点
			copyNode->pRight = (TreeNode*)malloc(sizeof(struct TreeNode));
			copyNode->pRight->init(node1->pRight->nValue);

			copyQueue.push(copyNode->pRight);
		}
	}

	return newTree;
}