微软算法面试(10)：输入一颗二元查找树，将该树转换为它的镜像

题目：输入一颗二元查找树，将该树转换为它的镜像，
即在转换后的二元查找树中，左子树的结点都大于右子树的结点。
用递归和循环两种方法完成树的镜像转换。

例如：
8
/ /
6 10
// //
5 7 9 11

输出：
8
/ /
10 6
// //
11 9 7 5
分析：

可以使用递归思想，BTree* root ; 先转换左子树(root->left), 再转换右子树（root->right），最后把左子树的结果和右子树的结果对换下，就OK了。
很简单吧，看看实现：

#include<iostream>

using namespace std;

struct BTree{
	BTree(int _v):value(_v), left(NULL), right(NULL) {}
	int value;
	BTree* left;
	BTree* right;
	void add(BTree* _bt)
	{
		if(_bt->value < value)
		{
			if(left == NULL)
				left = _bt;
			else
				left->add(_bt);
		}
		else
		{
			if(right == NULL)
				right = _bt;
			else
				right->add(_bt);
		}
	}
};

void transBTree(BTree* bt)
{
	if(bt == NULL) return;
	if(bt->left != NULL) transBTree(bt->left);
	if(bt->right != NULL) transBTree(bt->right);
	BTree* ptmp = bt->left;
	bt->left = bt->right;
	bt->right = ptmp;
}

template <typename T, int size=1024>
class queue{
private:
	T data[size];
	int begin, end;
public:
	queue():begin(0),end(0){}
	bool empty()
	{
		return begin == end;
	}
	void push(T& _d)
	{
		if((end +1)%size == begin) 
		{
			cout << "queue is full, cann't push any node." <<endl;
			return;
		}
		data[end] = _d;
		end = (end + 1)%size;
	}

	T& pop(T& _t)
	{
		if(end == begin)
		{
			cout << "queue is empty, cann't pop any node." <<endl;
			return _t;
		}
		_t = data[begin];
		begin = (begin + 1)%size;
		return _t;
	}
};

void print(BTree* root)
{
	queue<BTree*> q;
	BTree* node = root;
	BTree _n1(-1);//空标记
	q.push(node);
	while(!q.empty())
	{
		BTree* _bsn = &_n1;
		q.pop(_bsn);
		cout << _bsn->value << " ";

		if(_bsn->left != NULL)
			q.push(_bsn->left);

		if(_bsn->right != NULL)
			q.push(_bsn->right);
	}
}

int main()
{
	BTree* root;
        BTree bt1(8);
        BTree bt2(6);
        BTree bt3(10);
        BTree bt4(5);
        BTree bt5(7);
        BTree bt6(9);
        BTree bt7(11);

        root = &bt1;
        root->add(&bt2);
        root->add(&bt3);
        root->add(&bt4);
        root->add(&bt5);
        root->add(&bt6);
        root->add(&bt7);

	cout << "按层次，从左到右打印结果为：";
	print(root);	
	cout << endl;
	transBTree(root);
	cout << "转换后：按层次，从左到右打印结果为：";
	print(root);	
	return 0;
}

输出结果为：

按层次，从左到右打印结果为：8 6 10 5 7 9 11

转换后：按层次，从左到右打印结果为：8 10 6 11 9 7 5