程序员面试题精选(11)－求二元查找树的镜像

题目：输入一颗二元查找树，将该树转换为它的镜像，即在转换后的二元查找树中，左子树的结点都大于右子树的结点。用递归和循环两种方法完成树的镜像转换。 例如输入：
      8
     /   \
   6       10
/\        /\
5   7     9    11
输出：
       8
     /   \
   10     6
/\       /\
11   9   7   5
定义二元查找树的结点为：

C++代码

1. struct BSTreeNode // a node in the binary search tree (BST)   
2. {   
3.       int           m_nValue; // value of node   
4.        BSTreeNode   *m_pLeft;  // left child of node   
5.        BSTreeNode   *m_pRight; // right child of node   
6. };  

struct BSTreeNode // a node in the binary search tree (BST)
{
      int           m_nValue; // value of node
       BSTreeNode   *m_pLeft;  // left child of node
       BSTreeNode   *m_pRight; // right child of node
};

分析：尽管我们可能一下子不能理解镜像是什么意思，但上面的例子给我们的直观感觉，就是交换结点的左右子树。我们试着在遍历例子中的二元查找树的同时来交换每个结点的左右子树。遍历时首先访问头结点8，我们交换它的左右子树得到：
       8
     /   \
   10     6
/\       /\
9   11   5   7
我们发现两个结点6和10的左右子树仍然是左结点的值小于右结点的值，我们再试着交换他们的左右子树，得到：
       8
     /   \
   10     6
/\       /\
11   9 7    5
刚好就是要求的输出。
上面的分析印证了我们的直觉：在遍历二元查找树时每访问到一个结点，交换它的左右子树。这种思路用递归不难实现，将遍历二元查找树的代码稍作修改就可以了。参考代码如下：

C++代码

1. ///   
2. // Mirror a BST (swap the left right child of each node) recursively   
3. // the head of BST in initial call   
4. ///   
5. void MirrorRecursively(BSTreeNode *pNode)   
6. {   
7.       if(!pNode)   
8.             return;   
9.   
10.       // swap the right and left child sub-tree   
11.        BSTreeNode *pTemp = pNode->m_pLeft;   
12.        pNode->m_pLeft = pNode->m_pRight;   
13.        pNode->m_pRight = pTemp;   
14.   
15.       // mirror left child sub-tree if not null   
16.       if(pNode->m_pLeft)   
17.              MirrorRecursively(pNode->m_pLeft);     
18.   
19.       // mirror right child sub-tree if not null   
20.       if(pNode->m_pRight)   
21.              MirrorRecursively(pNode->m_pRight);    
22. }  

///
// Mirror a BST (swap the left right child of each node) recursively
// the head of BST in initial call
///
void MirrorRecursively(BSTreeNode *pNode)
{
      if(!pNode)
            return;

      // swap the right and left child sub-tree
       BSTreeNode *pTemp = pNode->m_pLeft;
       pNode->m_pLeft = pNode->m_pRight;
       pNode->m_pRight = pTemp;

      // mirror left child sub-tree if not null
      if(pNode->m_pLeft)
             MirrorRecursively(pNode->m_pLeft);  

      // mirror right child sub-tree if not null
      if(pNode->m_pRight)
             MirrorRecursively(pNode->m_pRight); 
}

由于递归的本质是编译器生成了一个函数调用的栈，因此用循环来完成同样任务时最简单的办法就是用一个辅助栈来模拟递归。首先我们把树的头结点放入栈中。在循环中，只要栈不为空，弹出栈的栈顶结点，交换它的左右子树。如果它有左子树，把它的左子树压入栈中；如果它有右子树，把它的右子树压入栈中。这样在下次循环中就能交换它儿子结点的左右子树了。参考代码如下：

C++代码

1. ///   
2. // Mirror a BST (swap the left right child of each node) Iteratively   
3. // Input: pTreeHead: the head of BST   
4. ///   
5. void MirrorIteratively(BSTreeNode *pTreeHead)   
6. {   
7.       if(!pTreeHead)   
8.             return;   
9.   
10.       std::stack<BSTreeNode *> stackTreeNode;   
11.        stackTreeNode.push(pTreeHead);   
12.   
13.       while(stackTreeNode.size())   
14.        {   
15.              BSTreeNode *pNode = stackTreeNode.top();   
16.              stackTreeNode.pop();   
17.   
18.             // swap the right and left child sub-tree   
19.              BSTreeNode *pTemp = pNode->m_pLeft;   
20.              pNode->m_pLeft = pNode->m_pRight;   
21.              pNode->m_pRight = pTemp;   
22.   
23.             // push left child sub-tree into stack if not null   
24.             if(pNode->m_pLeft)   
25.                    stackTreeNode.push(pNode->m_pLeft);   
26.   
27.             // push right child sub-tree into stack if not null   
28.             if(pNode->m_pRight)   
29.                    stackTreeNode.push(pNode->m_pRight);   
30.        }   
31. }