剑指offer 19---二叉树的镜像

二叉树的镜像 ：

镜像即就是在镜子中所成的像

代码实现：

PS:搜索二叉树和普通二叉树实现方法是相同的，只是两种建树过程有所不同，此处实现的是搜索二叉树。

1.递归实现：

#pragma once
#include <iostream>
#include <Windows.h>
#include <assert.h>

using namespace std;

template <class K>
struct SearchBinaryTreeNode
{
	K _key;
	SearchBinaryTreeNode<K>* _left;
	SearchBinaryTreeNode<K>* _right;

	SearchBinaryTreeNode(const K& key)
		:_key(key)
		, _left(NULL)
		, _right(NULL)
	{}
};

template <class K>
class SearchBinaryTree
{
	typedef SearchBinaryTreeNode<K> Node;
public:
	SearchBinaryTree()
		:_root(NULL)
	{}

	~SearchBinaryTree()
	{}

	bool Insert(const K& key)     //建树,递归实现
	{
		if (_root == NULL)
		{
			_root = new Node(key);
			return true;
		}
		Node* parent = NULL;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)       //要插入的值大于cur的值
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;      //不能有相同的key
			}
		}
		//此时找到要插入的位置
		if (parent->_key > key)
		{
			parent->_left = new Node(key);
			return true;
		}
		else
		{
			parent->_right = new Node(key);
			return true;
		}
	}

	void MirrorImage()       //递归实现镜像
	{
		_MirrorImage(_root);
	}

	void InOrder()       //中序遍历
	{
		_InOrder(_root);
		cout << endl;
	}

protected:
	void _InOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

	void _MirrorImage(Node* cur)       //递归实现镜像
	{
		if (cur == NULL)
		{
			return;
		}
		if (cur->_left == NULL && cur->_right == NULL)
		{
			return;
		}
		//只要当前节点有一个孩子不为空，即可交换
		Node* temp = cur->_left;
		cur->_left = cur->_right;
		cur->_right = temp;
		if (cur->_left)
		{
			_MirrorImage(cur->_left);
		}
		if (cur->_right)
		{
			_MirrorImage(cur->_right);
		}
	}

protected:
	Node* _root;     //根节点
};

#include "MirrorImage.h"

void TestMirrorImage()
{
	SearchBinaryTree<int> qq;
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	size_t size = sizeof(arr) / sizeof(arr[0]);
	for (size_t i = 0; i < size; ++i)
	{
		qq.Insert(arr[i]);
	}
	qq.InOrder();
	qq.MirrorImage();
	qq.InOrder();
}

int main()
{
	TestMirrorImage();
	system("pause");
	return 0;
}

2.非递归实现，借助栈

void _MirrorImage(Node* cur)         //非递归实现镜像
	{
		if (cur == NULL)
		{
			return;
		}
		stack<Node*> qq;
		qq.push(cur);
		while (!qq.empty())    //栈不为空时
		{
			Node* cur = qq.top();
			qq.pop();
			if (cur->_left != NULL || cur->_right != NULL)    //当前节点左右孩子只要有一个不为空，即可交换
			{
				Node* temp = cur->_left;
				cur->_left = cur->_right;
				cur->_right = temp;
			}
			if (cur->_left)
			{
				qq.push(cur->_left);
			}
			if (cur->_right)
			{
				qq.push(cur->_right);
			}
		}
	}