面试100题：15.求二叉树的镜像

转载并参考July的博客http://topic.csdn.net/u/20101126/10/b4f12a00-6280-492f-b785-cb6835a63dc9.html，万分感谢！

题目：

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

输入：

        8

     /    \

   6     10

 /  \     /  \

5   7   9   11

输出：

        8

    /       \

  10       6

 /   \      / \

11   9   7   5

分析：

利用递归遍历二叉树的左右子树，分别交换左右孩子。

/*Title:    15.求二叉树的镜像
Author:    gocode
Date:        2012-10-16*/
 
#include <iostream>
#include <stack>
using namespace std;
 
typedef struct Node
{
    int m_Data;
    Node* m_pLeft;
    Node* m_pRight;
} Node, BSTNode;
 
BSTNode* Root;
 
// 递归求镜像
void SeekBSTMirror(BSTNode* root)
{
    if(NULL == root)
        return;
    if(NULL != root->m_pLeft)
        SeekBSTMirror(root->m_pLeft);
    if(NULL != root->m_pRight)
        SeekBSTMirror(root->m_pRight);
 
    // 左右孩子交换
    if(NULL != root->m_pLeft && NULL != root->m_pRight)
    {
        BSTNode* tempNode = root->m_pLeft;
        root->m_pLeft = root->m_pRight;
        root->m_pRight = tempNode;
    }
 
    // 左叶子变右叶子
    if(NULL != root->m_pLeft && NULL == root->m_pRight)
    {
        BSTNode* pNewRightNode = new BSTNode();
        pNewRightNode = root->m_pLeft;
        root->m_pLeft = NULL;
        delete root->m_pLeft;
        root->m_pRight = pNewRightNode;
    }
 
    // 右叶子变左叶子
    if(NULL == root->m_pLeft && NULL != root->m_pRight)
    {
        BSTNode* pNewLeftNode = new BSTNode();
        pNewLeftNode = root->m_pRight;
        root->m_pRight = NULL;
        delete root->m_pRight;
        root->m_pLeft = pNewLeftNode;
    }
}
 
// 循环求镜像
BSTNode* SeekBSTMirror2(BSTNode* root)
{
    if(root != NULL) 
    { 
        stack<BSTNode *> stk;   //辅助栈  
        stk.push(root);           //压入根结点  
        while(stk.size()) 
        { 
            BSTNode *pNode = stk.top(); 
            BSTNode *pLeft = pNode->m_pLeft; 
            BSTNode* pRight = pNode->m_pRight; 
            stk.pop(); 
 
            if(pLeft != NULL) 
                stk.push(pLeft); 
            if(pRight != NULL) 
                stk.push(pRight); 
            pNode->m_pLeft = pRight;  //交换左右子女  
            pNode->m_pRight = pLeft; 
        } 
    } 
    return root;
}
 
// 创建二叉树
void AddBSTNode(BSTNode* &pCur, int key)
{
    if(NULL == pCur)
    {
        pCur = new BSTNode();
        pCur->m_Data = key;
        pCur->m_pLeft = NULL;
        pCur->m_pRight = NULL;
    }
    else if(key < pCur->m_Data)
        AddBSTNode(pCur->m_pLeft, key);
    else if(key > pCur->m_Data)
        AddBSTNode(pCur->m_pRight, key);
    else
        cout<<"Duplicate node is not allowed."<<endl;
}
 
// 中序遍历并打印二叉树结点
void DisplayBST(BSTNode* &root)
{
    if(NULL == root)
        return;
 
    if(NULL != root->m_pLeft)
        DisplayBST(root->m_pLeft);
 
    cout<<root->m_Data<<" ";
 
    if(NULL != root->m_pRight)
        DisplayBST(root->m_pRight);
}
 
void main()
{
    BSTNode* myRoot = NULL;
    AddBSTNode(myRoot, 8);
    AddBSTNode(myRoot, 6);
    AddBSTNode(myRoot, 10);
    AddBSTNode(myRoot, 5);
    AddBSTNode(myRoot, 7);
    AddBSTNode(myRoot, 9);
    AddBSTNode(myRoot, 11);
 
    cout<<"Original BST: "<<endl;
    DisplayBST(myRoot);
    cout<<endl<<"Solution 1 : recursion"<<endl;
    SeekBSTMirror(myRoot);
    DisplayBST(myRoot);
    cout<<endl<<"Solution 2: circulation"<<endl;
    SeekBSTMirror2(myRoot);
    DisplayBST(myRoot);
    cout<<endl;
    system("pause");
}