南辕北辙 沧海桑田

 ListNode< Type >* Search(ListNode< Type > *head,ListNode< Type > *p,Type key){
  if(p->data > key)
    while(p->data > key&&p !=NULL)p=p->llink;
  if(p->data < key)
    while(p->data < key&&p !=NULL)p=p->rlink;
  if(p->data == key)
    return p;
  else{ p=head;reutrn NULL;}
}

template< class Type >class Set{
  int Contains(const Type x);
  int SubSet(Set< Type >& right);
  int operator ==(Set< Type >&right);
  int Elemtype();
  Type GetData();
  char GetName();
  Set< Type >* GetSubSet();
  Set< Type >* GetNext();
  int IsEmpty();
};

ostream& operator<< (ostream& out,Set< Type >){
  t.traverse(out,t);return out;
}

void traverse(ostream&out, Set< Type >s){
  if(s.IsEmpty()==0){
    if(s.Elemtype()==0)out<< s.GetName()<< '{';
    else if(s.Elemtype()==1){
       out<< s.GetData;
       if(s.GetNext()!=NULL)out<< ',';
    }
    else{
         traverse(s.GetSubSet());
        if(s.GetNext()!=NULL)out<< ',';
    }
    traverse(s.GetNext());
  }
  else out<< '}';
}

template < class Type >class SetList;
template< class Type >class SetNode{
//这部分参考教材
friend class SetList< Type >;
public:
  SetNode(const Type& item)
   :data(item),link(NULL);
private:
  Type data;
  SetNode< Type >* link;
};

template< class Type >class SetList{
//这部分参考教材
public:
  SetList();
  ~SetList();
  SetList< Type > &operator+(SetList< Type >& right);
  SetList< Type > &operator*(SetList< Type >& right); 
  SetList< Type > &operator-(SetList< Type >& right); 
  int Contains(const Type &x);
  int AddMember(const Type &x);
  int DelMember(const Type &x);
  Type & Min();
private:
  SetNode< Type > *first,*last;
}

template< class Type >SetList< Type >& SetList< Type >
  ::operator+(SetList< Type >& right){
  SetNode< Type > *pb=right.first->link; //目标链
  SetNode< Type > *tmp=pa=first->link;   //tmp暂存first
  SetNode< Type > *pc=first;             //新加入
  int diff;                 //判断元素是否在A集合中出现
  while(pb!=NULL){
    diff=1;              //初始置为 不在A集合中出现
    for(pa=tmp;pa=pa->link;pa!=NULL)
      if(pb->data==pa->data){ 
  //如果相等,pa直接到链尾
        pa=last->link;
        diff=0;
      }
    if(diff==1)
      pc=pc->link=pb;    //加入pb
    pb=pb->link;
  }
  pc->link=tmp;          
//原来的A链加入新链的链尾
  return * this;
}

template< class Type >SetList< Type >& SetList< Type >
  ::operator*(SetList< Type >& right){
  SetNode< Type > *pb=right.first->link; //目标链
  SetNode< Type > *tmp=pa=first->link;   //tmp暂存first
  SetNode< Type > *pc=first;             //新加入
  int diff;                 //判断元素是否在A集合中出现
  while(pb!=NULL){
    diff=1;              //初始置为 不在A集合中出现
    for(pa=tmp;pa=pa->link;pa!=NULL)
      if(pb->data==pa->data){ 
  //如果相等,pa直接到链尾
        pa=last->link;
        diff=0;
      }
    if(diff==0)
      pc=pc->link=pb;    //加入pb
    pb=pb->link;
  }
  return * this;
}

template< class Type >SetList< Type >& SetList< Type >
  ::operator-(SetList< Type >& right){
  SetNode< Type > *pb=right.first->link; //目标链
  SetNode< Type > *pa=first;   //this链
  SetNode< Type > *tmp;             
  while(pb!=NULL){
    for(pa=first;pa=pa->link;pa->link!=NULL)
      if(pa->link->data==pb->data){
    如果B中有元素与A相等，则删去A中的该元素
         tmp=pa->link;
         pa->link=pa->link-link;
         delete tmp;
         pa=last;
      }
    pb=pb->link;
  }
  return * this;
}

template< class Type >int SetList< Type >
  ::Contains(const Type &x){
  SetNode< Type > *p=first->link;
  while(p!=NULL)
    if(p->data==x)
      return 1;
    else p=p->link;
  return 0;
}

template< class Type >int SetList< Type >
  ::AddMember(const Type &x){
  int i=Contains(x);
  if(i==1)
    return 0;
  else{
    last->link=new SetNode(x);
    last=last->link;
    return 1;
  }
}

template< class Type >int SetList< Type >
  ::DelMember(const Type &x){
  SetNode< Type > *p=first->link,*q=first;
  while(p!=NULL){
    if(p->data==x){
      q->link=p->link;
      if(p==last)last=q;
      delete p;
      return 1;
    }
    else{
      p=p->link;
      q=q->link;
    }
  }
  return 0;
}

template< class Type >Type& SetList< Type >::Min(){
//求集合中的最小元素.
  SetNode< Type > *p=first->link;
  if(p==NULL){
//如果是空表返回错误；
    cout<< "空表"<< endl;
    return;
  }
  Type minnum=p->data;
  p=p->link;
  while(p!=NULL){
    if(minnum > p->data)
      minnum=p->data
    p=p->link;
  }
  return minnum;
}