笔试算法题（25）：复制拥有多个指针的链表 & 判断二元树B是否为A的子树

出题：定义一个复杂链表：在单向链表的基础上，每个节点附加一个指向链表中其他任意节点的指针sibling，实现CNode* Clone(Cnode *head)函数复制这个复杂链表；

分析：

• 解法1：将head复制到CHead中，第一次遍历创建CHead中对应head的各个节点（next），第二次遍历创建CHead中对应head各个节 点的sibling链接，由于需要在CHead中找到对应head中的sibling节点，所以需要遍历CHead链表，但是可以用空间换时间的方法：使 用Hash Table存储CHead和head对应的节点对，这样head中定位了sibling之后，就可以知道CHead中对应sibling节点，时间复杂度 为O(N)，空间复杂度为O(N)；
• 解法2：注意给出的函数头中参数并没有使用const，而一般情况下的copy函数的参数都是const，所以可以推断可能需要改变原始数据的结构。使用 奇偶链表实现，将新创建的CHead中的各个节点对应安插到head中各个节点之后，这样CHead中与head中对等的节点就在head中节点的后面， 所以可以很容易确定sibling节点，最后仅读取偶数节点就是CHead，时间复杂度为O(N)，空间复杂度为O(1)。海涛老师再次威武！此方法参考 海涛老师的博客：
  http://zhedahht.blog.163.com/blog/static/254111742010819104710337/

解题：

 struct CNode {
         int value;
         CNode *next;
         CNode *sibling;
 };
 CNode* Clone(CNode *head) {
         if(head==NULL) return NULL;

         CNode *CHead=new CNode();
         CHead->value=head->value;
         CNode *cur, *pre=CHead, *temp=head->next, *CTemp;
         /**
          * 以next指针为线索创建链表节点
          * */
         while(temp!=NULL) {
                 cur=new CNode();
                 cur->value=temp->value;
                 pre->next=cur;
                 pre=cur;

                 temp=temp->next;
         }
         /**
          * 以next指针为线索创建sibling链接
          * */
         temp=head;CTemp=CHead;
         while(temp!=NULL) {
                 /**
                  * 将下面这句代码换成HashTable存储的head和CHead中
                  * 对等节点的存储对
                  * */
                 //CTemp->sibling=temp->sibling;
                 temp=temp->next;
                 CTemp=CTemp->next;
         }
         return CHead;
 }
 /**
  * 在head中每个节点的后面创建一个新节点，
  * 并复制之前节点的value，链接之前节点的
  * next节点
  * */
 void CreateNewNode(CNode *head) {
         CNode *index=head, *nNode, *next;
         while(index!=NULL) {
                 nNode=new CNode();
                 nNode->value=index->value;
                 nNode->sibling=NULL;

                 next=index->next;
                 index->next=nNode;
                 nNode->next=next;
                 index=next;
         }
 }
 /**
  * 顺序遍历head中奇数索引的节点，如果其sibling非NULL，则
  * 其sibling的next节点就是CHead中的对应节点的sibling
  * */
 void CopySibling(CNode *head) {
         CNode *index=head;
         while(index!=NULL) {
                 if(index->sibling!=NULL) {
                         index->next->sibling=
                                         index->sibling->next;
                 }
                 index=index->next->next;
         }
 }
 /**
  * 将head拆分成奇数索引节点和偶数索引节点，后者就是新clone
  * 的复杂链表
  * */
 CNode* Separate(CNode *head) {
         CNode *index=head, *clone;
         if(index!=NULL) {
                 clone=index->next;
                 index->next=index->next->next;
                 index=index->next;
         } else
                 return NULL;
         CNode *temp;
         while(index!=NULL) {
                 temp=index->next;
                 clone->next=temp;
                 index->next=temp->next;

                 clone=temp;
                 index=temp->next;
         }

         return clone;
 }
 void Deletion(CNode *head) {
         CNode *cur=head, *next;
         if(cur!=NULL) {
                 next=cur->next;
                 delete cur;
                 cur=next;
         }
 }

出题：输入两棵二元树的根节点A和B，判断B是否是A的一个子树结构；

分析：

• 首先在A中找到与B根节点的值相同的节点AB1（注意处理节点值相同的情况，首先判断当前找到的AB1是否匹配，如果不匹配则继续寻找下一个AB1），然 后同时递归AB1和B，如果B中某节点的值与AB1某节点的值不等，则返回false；
• 如果B中某节点有子节点（左右），而AB1中没有，则返回 false；当B递归完全之后（也就是到达NULL）返回true；

解题：

 struct Node {
         int value;
         Node *left;
         Node *right;
 };
 /**
  * son只能是father的一部分，其他情况都返回false
  * */
 bool compare(Node *father, Node *son) {
         if(son==NULL) return true;
         if(father==NULL) return false;
         if(father->value != son->value)
                 return false;
         else
                 return compare(father->left,son->left) &&
                                 compare(father->right,son->right);
 }
 /**
  * 注意处理节点值重复的情况，因为只能找到第一个节点，而正确
  * 的匹配可能发生在之后的拥有相同节点值的节点
  * */
 Node* findNode(Node *root, Node *target) {
         Node *temp=NULL; bool ismatch=true;
         if(root->value==target->value) {
                 if(compare(root, target)) {
                         printf("\nb1 is part of a1");
                         exit();
                 } else
                         ismatch=false;
         }
         if(!ismatch && root->left!=NULL)
                 temp=findNode(root->left,target);
         if(temp==NULL && root->right!=NULL)
                 temp=findNode(root->right,target);
         return temp;
 }