【剑指】27.二叉树的镜像

题目描述

• 操作给定的二叉树，将其变换为源二叉树的镜像。

算法分析

• 递归法：依次遍历二叉树每个节点，并调换其左右子树；
• 迭代法：(1)深度优先法，使用栈实现，优先调换左/右子树的结点，然后调换另一子树的结点；(2)广度优先法，使用队列实现，优先调换同深度的结点，然后调换子树结点。

提交代码：

class Solution {
public:
	/* 递归法 */
	void Mirror1(TreeNode *pRoot) {
		if (!pRoot)
			return;

		if (!pRoot->left && !pRoot->right)
			return;

		TreeNode *temp = pRoot->left;
		pRoot->left = pRoot->right;
		pRoot->right = temp;

		if (pRoot->left)
			Mirror1(pRoot->left);
		
		if (pRoot->right)
			Mirror1(pRoot->right);
	}

	/* 迭代法-深度优先,栈实现 */
	void Mirror2(TreeNode *pRoot) {
		if (!pRoot)
			return;

		stack<TreeNode*> treeNodesStack;
		treeNodesStack.push(pRoot);

		while (!treeNodesStack.empty())
		{
			TreeNode *pNode = treeNodesStack.top();
			treeNodesStack.pop();

			TreeNode *temp = pNode->left;
			pNode->left = pNode->right;
			pNode->right = temp;

			if (pNode->left)
				treeNodesStack.push(pNode->left);
			if (pNode->right)
				treeNodesStack.push(pNode->right);
		}
	}

	/* 迭代法-广度优先,队列实现 */
	void Mirror3(TreeNode *pRoot) {
		if (!pRoot)
			return;

		queue<TreeNode*> treeNodesQueue;
		treeNodesQueue.push(pRoot);

		while (!treeNodesQueue.empty())
		{
			TreeNode *pNode = treeNodesQueue.front();
			treeNodesQueue.pop();

			TreeNode *temp = pNode->left;
			pNode->left = pNode->right;
			pNode->right = temp;

			if (pNode->left)
				treeNodesQueue.push(pNode->left);
			if (pNode->right)
				treeNodesQueue.push(pNode->right);
		}
	}
};

测试代码：

// ====================测试代码====================
// 测试完全二叉树：除了叶子节点，其他节点都有两个子节点
//            8
//        6      10
//       5 7    9  11
void Test1()
{
	printf("=====Test1 starts:=====\n");
	TreeNode* pNode8 = CreateBinaryTreeNode(8);
	TreeNode* pNode6 = CreateBinaryTreeNode(6);
	TreeNode* pNode10 = CreateBinaryTreeNode(10);
	TreeNode* pNode5 = CreateBinaryTreeNode(5);
	TreeNode* pNode7 = CreateBinaryTreeNode(7);
	TreeNode* pNode9 = CreateBinaryTreeNode(9);
	TreeNode* pNode11 = CreateBinaryTreeNode(11);

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

	PrintTree(pNode8);
	Solution s;

	printf("=====Test1: s.Mirror1=====\n");
	s.Mirror1(pNode8);
	PrintTree(pNode8);

	printf("=====Test1: s.Mirror2=====\n");
	s.Mirror2(pNode8);
	PrintTree(pNode8);

	DestroyTree(pNode8);
}

// 测试二叉树：出叶子结点之外，左右的结点都有且只有一个左子结点
//            8
//          7   
//        6 
//      5
//    4
void Test2()
{
	printf("=====Test2 starts:=====\n");
	TreeNode* pNode8 = CreateBinaryTreeNode(8);
	TreeNode* pNode7 = CreateBinaryTreeNode(7);
	TreeNode* pNode6 = CreateBinaryTreeNode(6);
	TreeNode* pNode5 = CreateBinaryTreeNode(5);
	TreeNode* pNode4 = CreateBinaryTreeNode(4);

	ConnectTreeNodes(pNode8, pNode7, nullptr);
	ConnectTreeNodes(pNode7, pNode6, nullptr);
	ConnectTreeNodes(pNode6, pNode5, nullptr);
	ConnectTreeNodes(pNode5, pNode4, nullptr);

	PrintTree(pNode8); \
	Solution s;

	printf("=====Test2: s.Mirror1=====\n");
	s.Mirror1(pNode8);
	PrintTree(pNode8);

	printf("=====Test2: s.Mirror2=====\n");
	s.Mirror2(pNode8);
	PrintTree(pNode8);

	DestroyTree(pNode8);
}

// 测试二叉树：出叶子结点之外，左右的结点都有且只有一个右子结点
//            8
//             7   
//              6 
//               5
//                4
void Test3()
{
	printf("=====Test3 starts:=====\n");
	TreeNode* pNode8 = CreateBinaryTreeNode(8);
	TreeNode* pNode7 = CreateBinaryTreeNode(7);
	TreeNode* pNode6 = CreateBinaryTreeNode(6);
	TreeNode* pNode5 = CreateBinaryTreeNode(5);
	TreeNode* pNode4 = CreateBinaryTreeNode(4);

	ConnectTreeNodes(pNode8, nullptr, pNode7);
	ConnectTreeNodes(pNode7, nullptr, pNode6);
	ConnectTreeNodes(pNode6, nullptr, pNode5);
	ConnectTreeNodes(pNode5, nullptr, pNode4);

	PrintTree(pNode8);
	Solution s;

	printf("=====Test3: s.Mirror1=====\n");
	s.Mirror1(pNode8);
	PrintTree(pNode8);

	printf("=====Test3: s.Mirror2=====\n");
	s.Mirror2(pNode8);
	PrintTree(pNode8);

	DestroyTree(pNode8);
}

// 测试空二叉树：根结点为空指针
void Test4()
{
	printf("=====Test4 starts:=====\n");
	TreeNode* pNode = nullptr;

	PrintTree(pNode);
	Solution s;

	printf("=====Test4: s.Mirror1=====\n");
	s.Mirror1(pNode);
	PrintTree(pNode);

	printf("=====Test4: s.Mirror2=====\n");
	s.Mirror2(pNode);
	PrintTree(pNode);
}

// 测试只有一个结点的二叉树
void Test5()
{
	printf("=====Test5 starts:=====\n");
	TreeNode* pNode8 = CreateBinaryTreeNode(8);

	PrintTree(pNode8);
	Solution s;

	printf("=====Test4: s.Mirror1=====\n");
	s.Mirror1(pNode8);
	PrintTree(pNode8);

	printf("=====Test4: s.Mirror2=====\n");
	s.Mirror2(pNode8);
	PrintTree(pNode8);
}

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

	return 0;
}