软件设计艺术大师基本功--二叉树的镜像

Author: Frank

描述： 写一个函数，输入一个二叉树，输出它的镜像。

二叉树结点的定义：

typedef struct BinaryTreeNode
{
	int data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BinaryTreeNode;

分析：如下图所示二叉树

      ----镜像后-->    

只需各个结点的左右指针互换即可(保证每个结点被操作一次）:

递归的方式：

void MirrorRecursively(BinaryTreeNode* pHead)
{
	if (NULL == pHead)
		return;
	if (NULL == pHead->left && NULL == pHead->right)
		return;
	BinaryTreeNode* pTemp = pHead->left;
	pHead->left = pHead->right;
	pHead->right = pTemp;
	MirrorRecursively(pHead->left);
	MirrorRecursively(pHead->right);
}

 

循环方式：

std::stack<int>  太重要了！

//循环方式，借助stack来实现， 只需要能够将各个结点的左右指针交换且每个结点仅仅被操作一次即可！应该也可以借助队列来实现

using namespace std;
#include <stack>
void MirrorBinaryTree_while(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->left;
		parent->left = parent->right;
		parent->right = Temp;

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

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

	}
}

2020.10.22日面试时，手撕代码，又遇到该题，也是让用循环实现，完全忘记了曾经写过这个博客，我竟然实现了，而且就是以上方法，纪念以下：

void mirrorWhile(Node* root)
{
	if (nullptr == root) {
		return;
	}
	std::stack<Node*> stackCache;
	stackCache.push(root);
	while (!stackCache.empty()) {

		Node* p = stackCache.top();
		Node* tmp = p->right;
		p->right = p->left;
		p->left = tmp;
		stackCache.pop();

		if(p->right != nullptr)
			stackCache.push(p->right);
		if (p->left != nullptr)
		    stackCache.push(p->left);
	}

}


struct Node {
	Node(int v=0, Node* l=nullptr, Node* r=nullptr):
		val(v),left(l),right(r)
	{}
	int val;
	Node* left;
	Node* right;
};

 

------------------------------代码测试------------------------------

 

 

#include "stdafx.h"
#include "stdlib.h"

BinaryTreeNode* CreatBinaryNode(int data)
{
	BinaryTreeNode* temp = (BinaryTreeNode*)malloc(sizeof(BinaryTreeNode));
	temp->data = data; temp->left = NULL; temp->right = NULL;
	return temp;
}

void PrintBinaryTree(BinaryTreeNode* pHead)
{
	if (NULL == pHead)
		return;
	BinaryTreeNode* pNode = pHead;
	printf("Node %d	", pNode->data);
	PrintBinaryTree(pNode->left);
	PrintBinaryTree(pNode->right);
}

int main()
{
	BinaryTreeNode* pHead = NULL;
	pHead = CreatBinaryNode(8);
	pHead->left= CreatBinaryNode(6);
	pHead->right = CreatBinaryNode(10);
	pHead->left->left= CreatBinaryNode(5);
	pHead->left->right = CreatBinaryNode(7);
	pHead->right->left= CreatBinaryNode(9);
	pHead->right->right = CreatBinaryNode(11);
	PrintBinaryTree(pHead);
	printf("----------------------------\n");
	MirrorRecursively(pHead);
	PrintBinaryTree(pHead);
	getchar();
    return 0;
}