c++实现单向链表

一、问题描述

1、题目内容：集合的并、交和差运算

编写一个能演示执行集合的并、交和差运算的程序。

2、基本要求

由用户输入两组整数分别作为两个集合的元素，由程序计算它们的交、并和差集，并将运算结果输出。

3、测试数据

测试数据为两组正整数，范围最好在0~35000之间。

S1={3，5，6，9，12，27，35}；

S2={5，8，10，12，27，31，2，51，55，63}；

运行结果：

S1ÈS2={3，5，6，8，9，10，12，27，31，35，42，51，55，63},

S1ÇS2={5，12，27}

S1-S2={3，6，9，35}。

实现提示：

以有序链表表示正整数集合。

代码：

 //2013-3-12

 //list头文件

 //合理的设置模式（隔离变化）

 typedef int ElemType;

 //定义结点
 struct ListNode
 {
     ElemType data;
     ListNode* next;
 };

 //定义链表类
 //注意接口的粒度的合理性

 class List
 {
 private:
     ListNode* m_head;//头指针
     ListNode* m_tail;//尾指针
     int m_length;//链表的结点数目

 public:
     //
     List();
     //在链表的后面追加元素
     //重载该函数
     //值专递，方便输入
     //地址传递，提高效率
     void AppendNode(ListNode item);
     void AppendNode(ListNode* item);
     //清空链表
     void ClearList();
     //返回链表的长度
     int LengthList();
     //返回L中第index个元素
     //以0开始
     ListNode* GetList(int index);
     //遍历输出l中所有元素
     void TraverseList();
     //查找item元素，并在index中保存下标
     bool FindList(ListNode* item,int* index);
     //更新第index个元素
     bool UpdateList(int index,const ListNode item);
     //
     bool InsertList(ListNode* item,int index);
     //
     bool DeleteList(ListNode item);

     //
     void CopyList(List* list);
 };

 //2013-3-13

 //list cpp

 #include<iostream>

 #include"List.h"

 using namespace std;

 //
 List::List()
 {
     m_head=m_tail=NULL;
     m_length=;
 }

 //ok
 void List::AppendNode(ListNode item)
 {
     //在堆里分配的内存
     ListNode* pitem=new ListNode(item);

         //如果链表为空
     if (m_head==NULL)
     {
         m_head=pitem;
         m_tail=pitem;
         ++m_length;
     }else
     {
         //如果不为空
         m_tail->next=pitem;
         pitem->next=NULL;
         m_tail=pitem;
         ++m_length;
     }

 }

 //ok
 void List::AppendNode(ListNode* item)
 {
     //如果链表为空
     if (m_head==NULL)
     {
         m_head=item;
         m_tail=item;
         ++m_length;
     }else
     {
         //如果不为空
         m_tail->next=item;
         item->next=NULL;
         m_tail=item;//指针往后移
         ++m_length;
     }

 }

 void List::ClearList()
 {

     ListNode* cp;
     ListNode* np;
     cp=m_head;
     while (cp!=NULL)
     {
         np=cp->next;
         delete cp;
         cp=np;
     }
     m_tail=m_head=NULL;
     m_length=;

 }

 //ok
 int List::LengthList()
 {
     return m_length;
 }

 //0下标开始
 ListNode* List::GetList(int index)
 {
     int readindex=index-;
     ListNode* finder;

     if (readindex>m_length)
     {
         cout<<"查找失败."<<endl;
         return NULL;
     }

     //first node
     if (readindex==)
     {
         return m_head;
     }

     //last node
     if (readindex==(m_length-))
     {
         return m_tail;
     }

     //else
     finder=m_head;
     for (int i = ; i <= readindex; i++)
     {
         finder=finder->next;
     }
     return finder;
 }

 //ok
 void List::TraverseList()
 {
     ListNode* out=m_head;

     if (m_length!=)
     {
         while (out!=NULL)
         {
             cout<<out->data<<" ";
             out=out->next;
         }
     }
 }

 bool List::FindList(ListNode* item,int* index)
 {
     ListNode* currnode=m_head;
     int item_index=;

     while ((currnode->data!=item->data)&&item_index++<m_length-)
     {
         currnode=currnode->next;
     }

     if (item_index>=m_length)
     {
         *index=-;
         return false;
     }else
     {
         *index=item_index+;
         return true;
     }
 }

 //ok
 bool List::UpdateList(int index,const ListNode item)
 {
     ListNode* updatenode=GetList(index);
     if (updatenode!=NULL)
     {
         updatenode->data=item.data;
         return true;
     }
     return false;
 }

 //2013-3-14
 //
 // 在链表不为空的前提下
 //ok
 bool List::InsertList(ListNode* item,int index)
 {
     //找到将要插入的前一项
     ListNode* previtem=GetList(index);

     if (previtem==NULL)
     {
         cout<<"插入失败。"<<endl;
         return false;
     }

     //item指向previtem的下一个元素
     item->next=previtem->next;

     //previtem指向item
     previtem->next=item;

     previtem=item=NULL;
     //长度+1
     ++m_length;

     return true;
 }

 //
 //ok
 bool List::DeleteList(ListNode item)
 {
     //将要删除的元素的前驱变量
     ListNode* prevdelenode=m_head;

     //要删除的元素的指针
     ListNode* delenode=m_head;

     //
     while ((delenode->data!=item.data)&&delenode!=NULL)
     {
         prevdelenode=delenode;
         delenode=delenode->next;
     }

     if (delenode==NULL)
     {
         cout<<"不存在该元素。"<<endl;
         return false;
     }

     //如果是删除第一个
     if (delenode==m_head)
     {
         prevdelenode=NULL;
         m_head=m_head->next;
         delete delenode;
         --m_length;
         return true;
     }

     //如果是删除最后一个
     if (delenode==m_tail)
     {
         m_tail=prevdelenode;
         m_tail->next=NULL;

         prevdelenode=NULL;

         delete delenode;
         --m_length;
         return true;
     }

     //prevdelenode指向delenode的下个元素
     prevdelenode->next=delenode->next;
     //
     delenode->next=NULL;
     //
     delete delenode;
     //
     --m_length;

     return true;

 }

 void List::CopyList(List* list)
 {
     ListNode node={NULL,NULL};
     ListNode* datanode=list->m_head;
     while (datanode!=NULL)
     {
         node.data=datanode->data;
         AppendNode(node);
         datanode=datanode->next;
     }

 }

 //2013-3-14

 #include<iostream>

 #include"List.h"

 using namespace std;

 int main()
 {
     List set1;
     List set2;

     List add_set;//并集
     List same_set;//交集
     List cut_set;//差集

     ListNode node={NULL,NULL};
     cout<<"请输入set1的数值，以-1结束。"<<endl;
     while (cin>>(node.data),(node.data)!=-)
     {
         set1.AppendNode(node);
     }

     cout<<"请输入set2的数值，以-1结束。"<<endl;
     while (cin>>(node.data),(node.data)!=-)
     {
         set2.AppendNode(node);
     }

     //将set1复制到三个集合
     add_set.CopyList(&set1);
     same_set.CopyList(&set1);
     cut_set.CopyList(&set1);

     ListNode set2_node={NULL,NULL},set1_node={NULL,NULL};
     int nothing=;//作为函数参数引用
     //遍历set2集合
     for (int i = ; i <= set2.LengthList(); i++)
     {

         set2_node.data=set2.GetList(i)->data;

         //add_set
         if (!add_set.FindList(&set2_node,¬hing))//NULL=worng
         {
             add_set.AppendNode(set2_node);
         }

         //cut_set
         if (cut_set.FindList(&set2_node,¬hing))
         {
             cut_set.DeleteList(set2_node);
         }

     }

     //遍历set1集合
     for (int i = ; i <=set1.LengthList(); i++)
     {
         //same_set
         set1_node.data=set1.GetList(i)->data;

         if (!set2.FindList(&set1_node,¬hing))
         {
             same_set.DeleteList(set1_node);
         }
     }

     cout<<endl<<"并集:";
     add_set.TraverseList();
     cout<<endl<<"交集:";
     same_set.TraverseList();
     cout<<endl<<"差集:";
     cut_set.TraverseList();
     cout<<endl;

     char ch=getchar();
     return ;
 }