剑指offer面试题：求二叉树的镜像（递归、循环解法及测试用例）

最新推荐文章于 2022-09-17 16:18:16 发布

岩枭

最新推荐文章于 2022-09-17 16:18:16 发布

阅读量4.6k

点赞数 5

分类专栏：数据结构

本文链接：https://blog.csdn.net/yanxiaolx/article/details/52019871

版权

数据结构专栏收录该内容

37 篇文章 5 订阅

订阅专栏

题目：给定二叉树，将其变换为源二叉树的镜像。

二叉树的定义如下：

struct TreeNode

{

int val;

TreeNode* left;

TreeNode* right;

};

输入描述:

二叉树的镜像定义：

源二叉树

/ \

6 10

/ \ / \

5 7 9 11

镜像二叉树

/ \

10 6

/ \ / \

11 9 7 5

思路：

观察上面两个二叉树，很容易就可以得出下面求一棵树镜像的过程：

先序遍历这棵树的每个结点，如果遍历到的结点有子结点，则交换它的两个子结点。当交换完所有非叶子结点的左右子结点之后，就得到了树的镜像。

图制作的有点丑，但是基本可以表达清楚原理了，咳咳，若喷，请轻喷。

方法一：递归遍历法：

//递归实现二叉树的镜像，按照先序遍历，如果遇到空的节点或者叶子节点就返回，否则交换两个子树后再改变左右子树  
void MirrorBinaryTree1(BinaryTreeNode* root)
{
	if (root == NULL || (root->leftchild == NULL && root->rightchild == NULL))
	{
		return;
	}

	BinaryTreeNode * tmp = root->leftchild;
	root->leftchild = root->rightchild;
	root->rightchild = tmp;

	if (root->leftchild)
	{
		MirrorBinaryTree1(root->leftchild);
	}
	if (root->rightchild)
	{
		MirrorBinaryTree1(root->rightchild);
	}
	
}

方法二：循环压栈实现二叉树镜像

循环压栈示意图：

//循环实现二叉树的镜像，利用栈的“后进先出”特性打印
void MirrorBinaryTree2(BinaryTreeNode* root)
{
	if (root == NULL)
	{
		return;
	}

	stack<BinaryTreeNode*> stackTreeNode;
	stackTreeNode.push(root);

	while (stackTreeNode.size() > 0)
	{
		BinaryTreeNode *parent = stackTreeNode.top();
		stackTreeNode.pop();

		BinaryTreeNode *Temp = parent->leftchild;
		parent->leftchild = parent->rightchild;
		parent->rightchild = Temp;

		if (parent->leftchild)
		{
			stackTreeNode.push(parent->leftchild);
		}

		if (parent->rightchild)
		{
			stackTreeNode.push(parent->rightchild);
		}

	}
}

进行功能测试的时候分五种情况：

（1）测试完全二叉树：除了叶子节点，其他节点都有两个子节点

/ \

6 10

/ \ / \

5 7 9 11

（2）测试二叉树：出叶子结点之外，左右的结点都有且只有一个左子结点
8

/
7

/
6

/
5

/
4

（3）测试二叉树：出叶子结点之外，左右的结点都有且只有一个右子结点

8

\
7

\
6

\
5

\
4

（4）测试空二叉树：根结点为空指针

（5）测试只有一个结点的二叉树

完整代码及五种测试用例：

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

struct BinaryTreeNode
{
	int data;
	BinaryTreeNode* leftchild;
	BinaryTreeNode* rightchild;

	BinaryTreeNode(int t)
	{
		data = t;
		leftchild =  NULL;
		rightchild = NULL;
	}
};


void PreorderTravel(BinaryTreeNode* root)
{
	if (root == NULL)
	{
		return;
	}
	cout <<root->data << "    ";
	PreorderTravel(root->leftchild);
	PreorderTravel(root->rightchild);
}

//递归实现二叉树的镜像，按照先序遍历，如果遇到空的节点或者叶子节点就返回，否则交换两个子树后再改变左右子树  
void MirrorBinaryTree1(BinaryTreeNode* root)
{
	if (root == NULL || (root->leftchild == NULL && root->rightchild == NULL))
	{
		return;
	}

	BinaryTreeNode * tmp = root->leftchild;
	root->leftchild = root->rightchild;
	root->rightchild = tmp;

	if (root->leftchild)
	{
		MirrorBinaryTree1(root->leftchild);
	}
	if (root->rightchild)
	{
		MirrorBinaryTree1(root->rightchild);
	}
	
}

//循环实现二叉树的镜像，利用栈的“后进先出”特性打印
void MirrorBinaryTree2(BinaryTreeNode* root)
{
	if (root == NULL)
	{
		return;
	}

	stack<BinaryTreeNode*> stackTreeNode;
	stackTreeNode.push(root);

	while (stackTreeNode.size() > 0)
	{
		BinaryTreeNode *parent = stackTreeNode.top();
		stackTreeNode.pop();

		BinaryTreeNode *Temp = parent->leftchild;
		parent->leftchild = parent->rightchild;
		parent->rightchild = Temp;

		if (parent->leftchild)
		{
			stackTreeNode.push(parent->leftchild);
		}

		if (parent->rightchild)
		{
			stackTreeNode.push(parent->rightchild);
		}

	}
}


// ====================测试代码====================


// 测试完全二叉树：除了叶子节点，其他节点都有两个子节点
//            8
//      6        10
//   5  7      9  11

BinaryTreeNode* root;
void Test1()
{
	root = new BinaryTreeNode(8);
	root->leftchild = new BinaryTreeNode(6);
	root->rightchild = new BinaryTreeNode(10);
	BinaryTreeNode* tmp = root->leftchild;
	tmp->leftchild = new BinaryTreeNode(5);
	tmp->rightchild = new BinaryTreeNode(7);
	tmp = root->rightchild;
	tmp->leftchild = new BinaryTreeNode(9);
	tmp->rightchild = new BinaryTreeNode(11);

	cout << "Test1:测试完全二叉树,除了叶子节点，其他节点都有两个子节点" << endl;
	cout << "原二叉树的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;
	
	MirrorBinaryTree1(root);
	cout << "二叉树镜像后的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;

	/*MirrorBinaryTree2(root);
	cout << "二叉树镜像后的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;*/
}


// 测试二叉树：出叶子结点之外，左右的结点都有且只有一个左子结点
//            8
//          7   
//        6 
//      5
//    4
void Test2()
{
	root = new BinaryTreeNode(8);
	root->leftchild = new BinaryTreeNode(7);
	root->rightchild = NULL;

	BinaryTreeNode* tmp = root->leftchild;
	tmp->leftchild = new BinaryTreeNode(6);
	tmp->rightchild = NULL;

	tmp = tmp->leftchild;
	tmp->leftchild = new BinaryTreeNode(5);
	tmp->rightchild = NULL;

	tmp = tmp->leftchild;
	tmp->leftchild = new BinaryTreeNode(4);
	tmp->rightchild = NULL;

	cout << "Test2: 测试二叉树,出叶子结点之外，左右的结点都有且只有一个左子结点" << endl;
	cout << "原二叉树的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;

	MirrorBinaryTree1(root);
	cout << "二叉树镜像后的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;

	/*MirrorBinaryTree2(root);
	cout << "二叉树镜像后的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;*/
}

// 测试二叉树：出叶子结点之外，左右的结点都有且只有一个右子结点
//            8
//             7   
//              6 
//               5
//                4
void Test3()
{
	root = new BinaryTreeNode(8);
	root->leftchild = NULL;
	root->rightchild = new BinaryTreeNode(7);

	BinaryTreeNode* tmp = root->rightchild;
	tmp->leftchild = NULL;
	tmp->rightchild = new BinaryTreeNode(6);
	
	tmp = tmp->rightchild;
	tmp->leftchild = NULL;
	tmp->rightchild = new BinaryTreeNode(5);
	
	tmp = tmp->rightchild;
	tmp->leftchild = NULL;
	tmp->rightchild = new BinaryTreeNode(4);

	cout << "Test3:测试二叉树出叶子结点之外，左右的结点都有且只有一个右子结点" << endl;
	cout << "原二叉树的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;

	MirrorBinaryTree1(root);
	cout << "二叉树镜像后的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;

	/*MirrorBinaryTree2(root);
	cout << "二叉树镜像后的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;*/
}

// 测试空二叉树：根结点为空指针
void Test4()
{
	root = NULL;

	cout << "Test4:测试空二叉树,根结点为空指针" << endl;
	cout << "原二叉树的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;

	MirrorBinaryTree1(root);
	cout << "二叉树镜像后的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;

	/*MirrorBinaryTree2(root);
	cout << "二叉树镜像后的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;*/
}


// 测试只有一个结点的二叉树
void Test5()
{
	root = new BinaryTreeNode(8);
	root->leftchild = NULL;
	root->rightchild = NULL;

	cout << "Test5:测试只有一个结点8的二叉树" << endl;
	cout << "原二叉树的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;

	MirrorBinaryTree1(root);
	cout << "二叉树镜像后的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;

	/*MirrorBinaryTree2(root);
	cout << "二叉树镜像后的先序遍历" << endl;
	PreorderTravel(root);
	cout << endl;*/
}


int main()
{
	Test1();
	Test2();
	Test3();
	Test4();
	Test5();

	system("pause");
	return 0;
}

运行结果：

Test1:测试完全二叉树,除了叶子节点，其他节点都有两个子节点

原二叉树的先序遍历

8 6 5 7 10 9 11

二叉树镜像后的先序遍历

8 10 11 9 6 7 5

Test2: 测试二叉树,出叶子结点之外，左右的结点都有且只有一个左子结点

原二叉树的先序遍历

8 7 6 5 4

二叉树镜像后的先序遍历

8 7 6 5 4

Test3:测试二叉树出叶子结点之外，左右的结点都有且只有一个右子结点

原二叉树的先序遍历

8 7 6 5 4

二叉树镜像后的先序遍历

8 7 6 5 4

Test4:测试空二叉树,根结点为空指针

原二叉树的先序遍历

二叉树镜像后的先序遍历

Test5:测试只有一个结点8的二叉树

原二叉树的先序遍历

二叉树镜像后的先序遍历

请按任意键继续. . .

岩枭

关注

5
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
剑指offer面试题：求二叉树的镜像（递归、循环解法及测试用例）

题目：给定二叉树，将其变换为源二叉树的镜像。二叉树的定义如下：struct TreeNode{ int val; TreeNode* left; TreeNode* right;};输入描述:二叉树的镜像定义：源二叉树 8 / \ 6 10 / \
复制链接

扫一扫