剑指offer——面试题26：判断二叉树B是否为二叉树A的子结构

 #include"iostream"
 #include"stdio.h"
 #include"math.h"
 using namespace std;

 struct BinaryTreeNode
 {
     double m_Value;
     BinaryTreeNode* m_pLeft;
     BinaryTreeNode* m_pRight;
 };

 BinaryTreeNode* CreateBinaryTreeNode(double value)
 {
     BinaryTreeNode* pNode=new BinaryTreeNode();
     pNode->m_Value=value;
     pNode->m_pLeft=nullptr;
     pNode->m_pRight=nullptr;

     return pNode;
 }

 void ConnectTreeNodes(BinaryTreeNode* pParent,BinaryTreeNode* pLeft,BinaryTreeNode* pRight)
 {
     if(pParent!=nullptr)
     {
         pParent->m_pLeft=pLeft;
         pParent->m_pRight=pRight;
     }
 }

 void PrintTreeNode(const BinaryTreeNode* pNode)
 {
     if(pNode!=nullptr)
     {
         cout<<"value of this node is:"<<pNode->m_Value<<endl;

         if(pNode->m_pLeft!=nullptr)
             cout<<"value of its left child is:"<<pNode->m_pLeft->m_Value<<endl;
         else
             cout<<"left child is nullptr."<<endl;
         if(pNode->m_pRight!=nullptr)
             cout<<"value of its right child is:"<<pNode->m_pRight->m_Value<<endl;
         else
             cout<<"right child is nullptr."<<endl;
     }
     else
         cout<<"this node is nullptr."<<endl;
     cout<<endl;
 }

 void PrintTree(const BinaryTreeNode* pRoot)
 {
     PrintTreeNode(pRoot);

     if(pRoot!=nullptr)
     {
         if(pRoot->m_pLeft!=nullptr)
             PrintTreeNode(pRoot->m_pLeft);

         if(pRoot->m_pRight!=nullptr)
             PrintTreeNode(pRoot->m_pRight);
     }
 }

 void DestroyTree(BinaryTreeNode* pRoot)
 {
     if(pRoot!=nullptr)
     {
         BinaryTreeNode* pLeft=pRoot->m_pLeft;
         BinaryTreeNode* pRight=pRoot->m_pRight;

         delete pRoot;
         pRoot=nullptr;

         DestroyTree(pLeft);
         DestroyTree(pRight);
     }
 }

 bool Equal(const double &a,const double &b)
 {
     if(fabs(a-b)<0.0000001)
         return true;
     return false;
 }

 bool DoesTreeAHaveTreeB(BinaryTreeNode* pRootA,BinaryTreeNode* pRootB)
 {
     if(pRootB==nullptr)
         return true;
     if(pRootA==nullptr)
         return false;

     if(Equal(pRootA->m_Value,pRootB->m_Value))
     {
        return DoesTreeAHaveTreeB(pRootA->m_pLeft,pRootB->m_pLeft)&&DoesTreeAHaveTreeB(pRootA->m_pRight,pRootB->m_pRight);
     }
     else
     {
         return false;
     }
 }
 bool HasSubTree(BinaryTreeNode* pRootA,BinaryTreeNode* pRootB)
 {
     if(pRootB==nullptr)
         return false;
     if(pRootA==nullptr)
         return false;

     bool result=false;

     if(Equal(pRootA->m_Value,pRootB->m_Value))
     {
         result=DoesTreeAHaveTreeB(pRootA,pRootB);
     }
     if(!result)
     {
         result=HasSubTree(pRootA->m_pLeft,pRootB);
     }
     if(!result)
     {
         result=HasSubTree(pRootA->m_pRight,pRootB);
     }

     return result;
 }

函数

 #include"BinaryTree.h"

 // ====================测试代码====================
 void Test(char* testName, BinaryTreeNode* pRoot1, BinaryTreeNode* pRoot2, bool expected)
 {
     if(HasSubTree(pRoot1, pRoot2) == expected)
         printf("%s passed.\n", testName);
     else
         printf("%s failed.\n", testName);
 }

 // 树中结点含有分叉，树B是树A的子结构
 //                  8                8
 //              /       \           / \
 //             8         7         9   2
 //           /   \
 //          9     2
 //               / \
 //              4   7
 void Test1()
 {
     BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA6 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA7 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeA1, pNodeA2, pNodeA3);
     ConnectTreeNodes(pNodeA2, pNodeA4, pNodeA5);
     ConnectTreeNodes(pNodeA5, pNodeA6, pNodeA7);

     BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeB1, pNodeB2, pNodeB3);

     Test("Test1", pNodeA1, pNodeB1, true);

     DestroyTree(pNodeA1);
     DestroyTree(pNodeB1);
 }

 // 树中结点含有分叉，树B不是树A的子结构
 //                  8                8
 //              /       \           / \
 //             8         7         9   2
 //           /   \
 //          9     3
 //               / \
 //              4   7
 void Test2()
 {
     BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA6 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA7 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeA1, pNodeA2, pNodeA3);
     ConnectTreeNodes(pNodeA2, pNodeA4, pNodeA5);
     ConnectTreeNodes(pNodeA5, pNodeA6, pNodeA7);

     BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeB1, pNodeB2, pNodeB3);

     Test("Test2", pNodeA1, pNodeB1, false);

     DestroyTree(pNodeA1);
     DestroyTree(pNodeB1);
 }

 // 树中结点只有左子结点，树B是树A的子结构
 //                8                  8
 //              /                   /
 //             8                   9
 //           /                    /
 //          9                    2
 //         /
 //        2
 //       /
 //
 void Test3()
 {
     BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeA1, pNodeA2, nullptr);
     ConnectTreeNodes(pNodeA2, pNodeA3, nullptr);
     ConnectTreeNodes(pNodeA3, pNodeA4, nullptr);
     ConnectTreeNodes(pNodeA4, pNodeA5, nullptr);

     BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeB1, pNodeB2, nullptr);
     ConnectTreeNodes(pNodeB2, pNodeB3, nullptr);

     Test("Test3", pNodeA1, pNodeB1, true);

     DestroyTree(pNodeA1);
     DestroyTree(pNodeB1);
 }

 // 树中结点只有左子结点，树B不是树A的子结构
 //                8                  8
 //              /                   /
 //             8                   9
 //           /                    /
 //          9                    3
 //         /
 //        2
 //       /
 //
 void Test4()
 {
     BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeA1, pNodeA2, nullptr);
     ConnectTreeNodes(pNodeA2, pNodeA3, nullptr);
     ConnectTreeNodes(pNodeA3, pNodeA4, nullptr);
     ConnectTreeNodes(pNodeA4, pNodeA5, nullptr);

     BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeB1, pNodeB2, nullptr);
     ConnectTreeNodes(pNodeB2, pNodeB3, nullptr);

     Test("Test4", pNodeA1, pNodeB1, false);

     DestroyTree(pNodeA1);
     DestroyTree(pNodeB1);
 }

 // 树中结点只有右子结点，树B是树A的子结构
 //       8                   8
 //        \                   \
 //         8                   9
 //          \                   \
 //           9                   2
 //            \
 //             2
 //              \
 //               5
 void Test5()
 {
     BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeA1, nullptr, pNodeA2);
     ConnectTreeNodes(pNodeA2, nullptr, pNodeA3);
     ConnectTreeNodes(pNodeA3, nullptr, pNodeA4);
     ConnectTreeNodes(pNodeA4, nullptr, pNodeA5);

     BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeB1, nullptr, pNodeB2);
     ConnectTreeNodes(pNodeB2, nullptr, pNodeB3);

     Test("Test5", pNodeA1, pNodeB1, true);

     DestroyTree(pNodeA1);
     DestroyTree(pNodeB1);
 }

 // 树A中结点只有右子结点，树B不是树A的子结构
 //       8                   8
 //        \                   \
 //         8                   9
 //          \                 / \
 //           9               3   2
 //            \
 //             2
 //              \
 //               5
 void Test6()
 {
     BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeA1, nullptr, pNodeA2);
     ConnectTreeNodes(pNodeA2, nullptr, pNodeA3);
     ConnectTreeNodes(pNodeA3, nullptr, pNodeA4);
     ConnectTreeNodes(pNodeA4, nullptr, pNodeA5);

     BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB4 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeB1, nullptr, pNodeB2);
     ConnectTreeNodes(pNodeB2, pNodeB3, pNodeB4);

     Test("Test6", pNodeA1, pNodeB1, false);

     DestroyTree(pNodeA1);
     DestroyTree(pNodeB1);
 }

 // 树A为空树
 void Test7()
 {
     BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeB4 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeB1, nullptr, pNodeB2);
     ConnectTreeNodes(pNodeB2, pNodeB3, pNodeB4);

     Test("Test7", nullptr, pNodeB1, false);

     DestroyTree(pNodeB1);
 }

 // 树B为空树
 void Test8()
 {
     BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode();
     BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode();

     ConnectTreeNodes(pNodeA1, nullptr, pNodeA2);
     ConnectTreeNodes(pNodeA2, pNodeA3, pNodeA4);

     Test("Test8", pNodeA1, nullptr, false);

     DestroyTree(pNodeA1);
 }

 // 树A和树B都为空
 void Test9()
 {
     Test("Test9", nullptr, nullptr, false);
 }

 int main(int argc, char* argv[])
 {
     Test1();
     Test2();
     Test3();
     Test4();
     Test5();
     Test6();
     Test7();
     Test8();
     Test9();

     return ;
 }

测试代码