《剑指offer》19题自己实现求普通二叉树的镜像

为了面试，看了何海涛的《剑指Offer》19题求求普通二叉树的镜像，决定通过自己的理解实现之，话不多说，立刻贴源码

//下面是 TreeOperate 类的实现

#include "BinTree.h"
#include <iostream>
#include <cstdlib>
//This function is to be used to construct a binary tree
void TreeOperate::connect(BinaryTreeNode *pRoot, BinaryTreeNode *pLeft, BinaryTreeNode *pRight){
    if (pRoot == NULL)
        abort();
    pRoot->m_pLeft = pLeft;
    pRoot->m_pRight = pRight;
}
//This function is to be used to destroy a tree and recycle space the tree used
void TreeOperate::destroy(BinaryTreeNode *&pRoot){
    if (pRoot == NULL) return;
    destroy(pRoot->m_pLeft);
    destroy(pRoot->m_pRight);
    delete pRoot;
    
}
//This function is to used to print the tree nodes in the preorder
void TreeOperate::prePrint(BinaryTreeNode *pRoot){
    if (pRoot == NULL) return;
    printf("%d
", pRoot->m_nValue);
    
    prePrint(pRoot->m_pLeft);
    prePrint(pRoot->m_pRight);

}
//This function is ultimate. It is used to return the root whose subtrees have been swapped if necessary.
BinaryTreeNode *TreeOperate::mirrorTree(BinaryTreeNode *pRoot){
    //pRoot == NULL ,which is a bad case bringing about serious problems.We have to avoid it.
    if (pRoot == NULL) abort();
    //The root has no subtree so there is no need to do anything.
    if (pRoot->m_pLeft == NULL && pRoot->m_pRight == NULL){
        return pRoot;
    }else{
        // The right subtree is not null.Set the left subtree to be the mirror tree of the right subtree. 
        if (pRoot->m_pLeft == NULL){
            pRoot->m_pLeft = mirrorTree(pRoot->m_pRight);
            pRoot->m_pRight = NULL;
            return pRoot;
        }
        // The left subtree is not null.Set the right subtree to be the mirror tree of the left subtree. 
        if (pRoot->m_pRight == NULL){
            pRoot->m_pRight = mirrorTree(pRoot->m_pLeft);
            pRoot->m_pLeft = NULL;
            return pRoot;
        }
        /*
         *Get the mirrorTrees of subtrees ,and then swap the subtrees.In this case,both of the subtrees are not null.
         */
        //The temporary variable is used to store the value of the root of the left subtree.The primary goal is for swapping.
        BinaryTreeNode *pTempNode = mirrorTree(pRoot->m_pLeft);
        pRoot->m_pLeft = mirrorTree(pRoot->m_pRight);
        pRoot->m_pRight = pTempNode;
        return pRoot;
    }
}

//下面是测试代码，为简单起见 nodeX 的m_nValue 就是 X

#include <iostream>
#include "BinTree.h"
using namespace std;
int main(){
	//Nodes shouldn't have the same space
	BinaryTreeNode *node1 = new BinaryTreeNode;
	node1->m_nValue = 1;
	node1->m_pLeft = NULL;
	node1->m_pRight = NULL;

	BinaryTreeNode *node2 = new BinaryTreeNode;
	node2->m_nValue = 2;
	node2->m_pLeft = NULL;
	node2->m_pRight = NULL;

	BinaryTreeNode *node3 = new BinaryTreeNode;
	node3->m_nValue = 3;
	node3->m_pLeft = NULL;
	node3->m_pRight = NULL;

	BinaryTreeNode *node4 = new BinaryTreeNode;
	node4->m_nValue = 4;
	node4->m_pLeft = NULL;
	node4->m_pRight = NULL;

	BinaryTreeNode *node5 = new BinaryTreeNode;
	node5->m_nValue = 5;
	node5->m_pLeft = NULL;
	node5->m_pRight = NULL;

	BinaryTreeNode *node6 = new BinaryTreeNode;
	node6->m_nValue = 6;
	node6->m_pLeft = NULL;
	node6->m_pRight = NULL;

	BinaryTreeNode *node7 = new BinaryTreeNode;
	node7->m_nValue = 7;
	node7->m_pLeft = NULL;
	node7->m_pRight = NULL;
	// All nodes have different memory space.You'd better be sure that nodeX != nodeY before using them.
	/*
	* Connect the node you need to build a tree. The first parameter is the root.The second is the left child of the root.The
	  third is the right child of the root.
	*/
	TreeOperate::connect(node1, node2, node3);
	TreeOperate::connect(node2, node4, node5);
	TreeOperate::connect(node3, node6, node7);

	//print the tree nodes in the preorder
	TreeOperate::prePrint(node1);
	cout << "***********" << endl;
	//mirrorTree
	BinaryTreeNode *pTemp = TreeOperate::mirrorTree(node1);
	TreeOperate::prePrint(node1);
	TreeOperate::destroy(node1);

	node1 = node2 = node3 = node4 = node5 = node6 = node7 = NULL;
	system("pause");

}

　　//下面是头文件的书写，一起贴上吧

#ifndef BINTREE_H
#define BINTREE_H
struct BinaryTreeNode{
    int m_nValue;
    BinaryTreeNode* m_pLeft;
    BinaryTreeNode* m_pRight;
};
class TreeOperate{
public:

    static void connect(BinaryTreeNode *, BinaryTreeNode *, BinaryTreeNode *);
    static void destroy(BinaryTreeNode *&);
    static void prePrint(BinaryTreeNode *);
    static BinaryTreeNode *mirrorTree(BinaryTreeNode *);
};
#endif

总结：递归函数的情况讨论详细和函数头的设计是至关重要的

欢迎去海涛哥的博客去看看 http://zhedahht.blog.163.com/