nyoj-1278-Prototypes analyze（二叉排序树模板）

题目链接

思路：建树之后，判断有多少种不同的树。

判断不同的树，简单的思路是遍历数组，判断数组后面是否存在一样的树

 /*
     Name:NYOJ-1278-Prototypes analyze
     Copyright:
     Author:
     Date: 2018/4/14 19:19:03
     Description:
     二叉排序树模板
 */
 #include<cstdio>
 #include<iostream>
 using namespace std;

 /*模板---------------------------------------------------------------*/
 typedef int ElemType;//定义ElemType的类型，可自己更改
 template<typename T>
 int getArrayLength(T &array) {
     return (sizeof(array) / sizeof(array[]));
 }
 //设计数据结构，构造二叉树
 typedef struct node {
     ElemType data;
     struct node *lchild, *rchild;
 }*BST;
 //插入元素
 bool insertBST(BST &T, ElemType element) {
     if (T==NULL)
     {
         T = new node;
         T->data = element;
         T->lchild = T->rchild = NULL;
         return true;
     }
     if (T->data==element)   //元素的值不能和树中已有的值相等
     {
         return false;
     }
     if (element<T->data)
     {
         insertBST(T->lchild,element);
     }
     else
     {
         insertBST(T->rchild,element);
     }
 }
 //创建二叉排序树
 void createBST(BST &T,ElemType array[],int len){   //Debug模式下，未初始化的栈内存上的指针全部填成0xcccccccc;
     T = NULL;
     for (int i = ; i < len; i++)
     {
         insertBST(T,array[i]);
     }
 }
 //访问，可改为数组保存
 void visit(ElemType elem) {
     cout << elem << "  ";
 }
 //中序遍历
 void preOrderTraverse(BST &T) {
     if (T!=NULL)
     {
         preOrderTraverse(T->lchild);
         visit(T->data);
         preOrderTraverse(T->rchild);
     }
 }
 //释放内存
 void relese(BST &T) {
     if (T==NULL)
     {
         return;
     }
     relese(T->lchild);
     relese(T->rchild);
     delete T;
 }
 //删除某个结点
 bool deleteNode(BST &T, ElemType element) {
     if (T==NULL)
     {
         return false;
     }
     BST p,q,s,parent;
     p = T;
     while (p!=NULL)
     {
         if (p->data == element)  break;
         parent = p;
         p = (p->data < element) ? p->rchild: p->lchild;
     }
     if (p==NULL)
     {
 //        cout << "该二叉排序树中无您要删除的值！"<<endl;
         return false;
     }
     if ((p->lchild==NULL)&&(p->rchild==NULL))
     {
         //重置其父亲结点的左右子孩子
         if (parent->lchild != NULL&&parent->lchild->data==element)
         {
             parent->lchild = NULL;
         }
         if (parent->rchild!=NULL&&parent->rchild->data==element)
         {
             parent->rchild = NULL;
         }
         return true;
     }
     else if (p->lchild!=NULL&&p->rchild==NULL)
     {
         //要让p的左孩子接上
         s=p->lchild;
         p ->data= s->data;
         p->lchild = s->lchild;
         delete s;
         return true;
     }
     else if (p->lchild==NULL&&p->rchild!=NULL)
     {
         //要让p的右孩子接上
         s = p->rchild;
         p->data = s->data;
         p->rchild = s->rchild;
         delete s;
         return true;
     }
     else
     {
         q = p;
         s = p->lchild;
         while (s->rchild!=NULL)
         {
             q = s;
             s = s->rchild;
         }
         p->data = s->data;
         if (q!=p)
         {
             q->rchild = s->lchild;
         }
         else
         {
             q->lchild = s->lchild;
         }
         delete s;
         return true;
     }
 }
 /*模板-------------------------------------------------------------结束*/

 int flag;
 void judge(BST T1,BST T2)  //判断形状；
 {
     if(T1==NULL&&T2==NULL)
         return;
     else if(T1&&T2)
     {
         judge(T1->lchild,T2->lchild);
         judge(T1->rchild,T2->rchild);
     }
     else
         flag=;
 }
 int main()
 {
     int t,n,k,x;
     BST tree[];

     scanf("%d",&t);
     while(t--)
     {
         scanf("%d%d",&n,&k);
         for(int i=; i<n; i++)
         {
             BST T=NULL;
             for(int j=; j<k; j++)  //建树；
             {
                 scanf("%d",&x);
                 insertBST(T,x);
             }
             tree[i]=T;
         }
         //找形状种类数；
         int ans=;
         for(int i=; i<n; i++)
         {
             int flog=;
             for(int j=i+; j<n; j++)
             {
                 flag=;
                 judge(tree[i],tree[j]);
                 if(flag)
                 {
                     flog=;
                     break;
                 }
             }
             if(flog)
                 ++ans;
         }
         printf("%d\n",ans);
     }
     return ;
 }