精华内容
下载资源
问答
  • #include <stdio.h> #include <stdlib.h> typedef int datatype; typedef struct node{ datatype data; struct node *next; }LNode,*LinkList; LinkList ...LinkList intersection(LinkList
    #include <stdio.h>
    #include <stdlib.h>
    typedef int datatype;
    typedef struct node{
    	datatype data;
    	struct node *next;
    }LNode,*LinkList;
    LinkList CreateLinkList(int *,int);
    LinkList Union(LinkList la,LinkList lb);
    LinkList intersection(LinkList la,LinkList lb);
    LinkList differnce(LinkList la,LinkList lb);
    void outputLinkList(LinkList L);
    int main()
    { int i=0;
      LNode *p;
      LinkList A,B,C,D,E;
      int a[]={20,30,40,50,60,70,80,90,100};
      int b[]={15,20,25,40,45,60,65,75,85,95};
      A=CreateLinkList(a,9);
      outputLinkList(A);
      B=CreateLinkList(b,10);
      outputLinkList(B);
      C=Union(A,B);
    printf("并集:\n"); 
    outputLinkList(C);
    D=intersection(A,B);
    printf("交集:\n");
    outputLinkList(D);   
    printf("差集:\n");
    E=differnce(A,B);
    outputLinkList(E);   
    
     
      /*计算集合的并*/
      
      /*计算集合的交*/ 
      
      /*计算集合的差*/
    }
    /*根据数组数据创建链表存储结构*/
    LinkList CreateLinkList(int a[],int n)
    { int i;
      LNode *pre,*p;
      LinkList L;
      L=pre=(LNode *)malloc(sizeof(LNode));
      for(i=0;i<n;i++)
      {  p=(LNode *)malloc(sizeof(LNode));
         p->data=a[i];
    	 pre->next=p;
    	 pre=p;
    	 }
      pre->next=NULL;
      return(L);
    }
    
    /*集合的并运算*/
    LinkList Union(LinkList la,LinkList lb)
    { LNode *pre,*p,*q,*s;
      LinkList L;
      p=la->next;
      q=lb->next;
      L=pre=(LNode *)malloc(sizeof(LNode));
      while(p&&q)
      { 
        s=(LNode *)malloc(sizeof(LNode));
    	  if(p->data<q->data)
    	   {  
            s->data=p->data;
            s->next=pre->next;
    		pre->next=s;
    		p=p->next; 
    		pre=pre->next;                                                                                                                                                   
    	     }
    	  else if(p->data==q->data)
    	   { /*把A集合当前元素放入结果集合中*/
           /*丢掉集合B当前元素*/
     s->data=p->data;
            s->next=pre->next;
    		pre->next=s;
    		p=p->next;        
    		q=q->next;
    			pre=pre->next;
    
    	    }
    	  else 
    { /*把B集合当前元素放入结果集合中*/
     
          s->data=q->data;
            s->next=pre->next;
    		pre->next=s;
    	         
    		q=q->next;
    			pre=pre->next;
    	    }
      }
     /*处理未处理完的链表*/
     p=p?p:q;
     while(p)
     {  
         s->data=p->data;
            s->next=pre->next;
    		pre->next=s;	pre=pre->next;
    	         
    		p=p->next;
    }
     pre->next=NULL;
     return(L);
    }
    /*集合的交运算*/
    LinkList intersection(LinkList la,LinkList lb)
    { LNode *pre,*p,*q,*s;
      LinkList L;
      p=la->next;
      q=lb->next;
      L=pre=(LNode *)malloc(sizeof(LNode));
      while(p&&q)
      { 
    	 if(p->data<q->data)
    	  { 
    	  p=p->next;
    
         }
    	else if(p->data==q->data)
    	{ 
    	   s=(LNode *)malloc(sizeof(LNode));
            s->data=p->data;
            s->next=pre->next;
    		pre->next=s;
    		p=p->next; 
    	    q=q->next;
    		pre=pre->next; 
    	
    
    	}
    	else 
    {  
    	  q=q->next;
    	   
    
        }
    	}
     pre->next=NULL;
     return(L);
    }
    /*集合的差运算*/
    LinkList differnce(LinkList la,LinkList lb)
    { LNode *pre,*p,*q,*s;
      LinkList L;
      p=la->next;
      q=lb->next;
      L=pre=(LNode *)malloc(sizeof(LNode));
      while(p&&q)
      { 
    	if(p->data<q->data)
    	 { 
    	 /* 把A中当前元素加入到结果集合中*/
    	    s->data=p->data;
        s->next=pre->next;
    		pre->next=s;
    		p=p->next; 
    		pre=pre->next;  
    	     
    
    	} 
    	else if(p->data==q->data)
    	{  /*丢掉A中当前元素*/
    /*丢掉B中当前元素*/
    p=p->next;
    q=q->next;
    	}
    	else 
    	{ 
    	  /*丢掉B中当前元素*/
    	  q=q->next;	}
      }
    /*如果A集合中还有剩余元素,把剩余元素放到结果集合中*/
    while(p)
     {  
            s->data=p->data;
            s->next=pre->next;
    		pre->next=s;
    		p=p->next; 
    		pre=pre->next;  
    	   
    
     } 
     pre->next=NULL;
     return(L);
    }
    /*输出链表的值*/
    void outputLinkList(LinkList L)
    { int i=0;
      LNode *p;
      p=L->next;
      while(p)
      { printf("%-6d",p->data);
        p=p->next;
        i++;
    	if(i%10==0) printf("\n");
      }
    printf("\n");
    }
    
    
    
    
    展开全文
  • 3.如何让指针对象初始化(指向单链表的表头) “LinlList.h” #define SLIST template <class T> struct Node{ T data; struct Node<T> *next; }; template class LinkList { public: LinkList(); ...
  • 单链表实现集合的并运算

    千次阅读 2018-10-24 17:48:34
    带头结点的单链表实现集合的并运算。 #include &lt;iostream&gt; //引用输入输出流库函数的头文件 using namespace std; template &lt;class T&gt; struct Node {  T data;  Node&...

    带头结点的单链表实现集合的并、交、差运算。

    #include <iostream>  //引用输入输出流库函数的头文件
    using namespace std;
    template <class T>
    struct Node
    {
      T data;
      Node<T> *next;  //此处<T>也可以省略
    };
    
    template <class T>
    class LinkList
    {
      public:
        LinkList( );  //建立只有头结点的空链表
        LinkList(T a[ ], int n);  //建立有n个元素的单链表
        ~LinkList();             //析构函数
        int Length();          //求单链表的长度
        T Get(int i);           //取单链表中第i个结点的元素值
        int Locate(T x);       //求单链表中值为x的元素序号
        void Insert(int i, T x);   //在单链表中第i个位置插入元素值为x的结点
        T Delete(int i);        //在单链表中删除第i个结点
        void PrintList( );           //遍历单链表,按序号依次输出各元素
     private:
       Node<T> *first;  //单链表的头指针
    };
    /*
    *前置条件:单链表不存在
    *输    入:无
    *功    能:构建一个单链表
    *输    出:无
    *后置条件:构建一个单链表
    */
    template <class T>
    LinkList<T>:: LinkList( )
    {
     first=new Node<T>; first->next=NULL;
    }
    /*
    *前置条件:单链表不存在
    *输    入:顺序表信息的数组形式a[],单链表长度n
    *功    能:将数组a[]中元素建为长度为n的单链表
    *输    出:无
    *后置条件:构建一个单链表
    */
    
    template <class T>
    LinkList<T>:: LinkList(T a[ ], int n)
     {
        first=new Node<T>;   //生成头结点
        Node<T> *r,*s;
         r=first;          //尾指针初始化
        for (int i=0; i<n; i++)
        {
          s=new Node<T>; s->data=a[i];  //为每个数组元素建立一个结点
          r->next=s; r=s;      //插入到终端结点之后
        }
        r->next=NULL;    //单链表建立完毕,将终端结点的指针域置空
     }
    
    
    /*
    *前置条件:无
    *输    入:无
    *功    能:无
    *输    出:无
    *后置条件:无
    */
    template <class T>
    LinkList<T>::~LinkList()
     {
         cout<<"~LinkList()"<<Length()<<endl;
    
          Node<T> *q;
         while(first!=NULL)
         {
             q=first;//cout<<q->data<<endl;
             first=first->next;
             delete q;
         }
     }
    /*
    *前置条件:单链表存在
    *输    入:查询元素位置i
    *功    能:按位查找位置为i的元素并输出值
    *输    出:查询元素的值
    *后置条件:单链表不变
    */
    template <class T>
    T LinkList<T>::Get(int i)
    {
      Node<T> *p; int j;
      p=first->next;  j=1;  //或p=first;  j=0;
      while (p && j<i)
      {
        p=p->next;       //工作指针p后移
        j++;
      }
      if (!p) throw "位置";
      else return p->data;
    }
    
    /*
    *前置条件:单链表存在
    *输    入:查询元素值x
    *功    能:按值查找值的元素并输出位置
    *输    出:查询元素的位置
    *后置条件:单链表不变
    */
    template <class T>
    int LinkList<T>::Locate(T x)
    {
        Node<T> *p; int j;
        p=first->next; j=1;
        while (p){
          if(p->data==x)    return j;
          else
          {
             p=p->next;
             j++;
          }
        }
        return 0;
    }
    
    /*
    *前置条件:单链表存在
    *输    入:插入元素x,插入位置i
    *功    能:将元素x插入到单链表中位置i处
    *输    出:无
    *后置条件:单链表插入新元素
    */
    template <class T>
    void LinkList<T>::Insert(int i, T x)
    {
       Node<T> *p; int j;
       p=first ; j=0;    //工作指针p初始化
       while (p && j<i-1)
       {
         p=p->next;   //工作指针p后移
         j++;
       }
       if (!p) throw "位置";
        else {
          Node<T> *s;
          s=new Node<T>;
          s->data=x;  //向内存申请一个结点s,其数据域为x
          s->next=p->next;       //将结点s插入到结点p之后
          p->next=s;
        }
    }
    
    /*
    *前置条件:单链表存在
    *输    入:无
    *功    能:输出单链表长度
    *输    出:单链表长度
    *后置条件:单链表不变
    */
    template <class T>
    int LinkList<T>::Length( )
    {
      Node <T> *p = first->next;
      int i = 0;
      while(p)
      {
        p = p->next;
        i++;
      }
      return i;
    }
    /*
    *前置条件:单链表存在
    *输    入:要删除元素位置i
    *功    能:删除单链表中位置为i的元素
    *输    出:无
    *后置条件:单链表删除元素
    */
    template <class T>
    T LinkList<T>::Delete(int i)
    {
      Node<T> *p; int j;
      p=first ; j=0;  //工作指针p初始化
      while (p && j<i-1)  //查找第i-1个结点
      {
        p=p->next;
        j++;
      }
      if (!p || !p->next) throw "位置";  //结点p不存在或结点p的后继结点不存在
        else {
              Node<T> *q; int x;
              q=p->next; x=q->data;  //暂存被删结点
              p->next=q->next;  //摘链
              delete q;
              return x;
        }
    }
    /*
    *前置条件:单链表存在
    *输    入:无
    *功    能:单链表遍历
    *输    出:输出所有元素
    *后置条件:单链表不变
    */
    template <class T>
    void LinkList<T>::PrintList( )
    {
        Node<T> *p;
        p=first->next;
        while (p)
        {
          cout<<p->data<<" ";
          p=p->next;
        }
        cout<<endl;
    }
    //LinkListMain.cpp
    template <typename T>
    void Unionset(LinkList <T> &a,LinkList <T> &b){//right
        //改变了a
        T temp;
        for(int i=1;i<=b.Length();i++)
        {
            temp=b.Get(i);
            if(!a.Locate(temp))a.Insert(a.Length()+1,temp);
        }
    }
    template <typename T>
    void Unionset1(LinkList <T> a,LinkList <T> b){
        //wrong: _CrtIsValidHeapPointer
        //因为函数返回时a,b被析构
        T temp;
        for(int i=1;i<=b.Length();i++)
        {
            temp=b.Get(i);
            if(!a.Locate(temp))a.Insert(a.Length()+1,temp);
        }
    }
    template <typename T>
    LinkList <T> Unionset2(LinkList <T> a,LinkList <T> b){
        //wrong: _CrtIsValidHeapPointer
        //因为函数返回时a,b被析构
        T temp;
        for(int i=1;i<=b.Length();i++)
        {
            temp=b.Get(i);
            if(!a.Locate(temp))a.Insert(a.Length()+1,temp);
        }
        return a;
    }
     template <typename T>
    void UnionSet(LinkList<T>&C,LinkList<T>&A,LinkList<T>&B)
    //A∪B=C
    {
        //LinkList<T> C;
        T temp;
        int i;
        for(i=1;i<=A.Length();i++)
        {
            temp=A.Get(i);
            C.Insert(C.Length()+1,temp);
        }
        for(i=1;i<=B.Length();i++)
        {
            temp=B.Get(i);
            if(!A.Locate(temp))C.Insert(C.Length()+1,temp);
        }
        //return C;
    
    }
    template <typename T>
    void IntersectionSet(LinkList<T>&C,LinkList<T>&A,LinkList<T>&B)
    //A∩B=C
     {
         //LinkList<T> C;
        T temp;
        int i;
    
        for(i=1;i<=B.Length();i++)
        {
            temp=B.Get(i);
            if(A.Locate(temp))C.Insert(C.Length()+1,temp);
        }
        //return C;
     }
     template <typename T>
    void IntersectionSet1(LinkList<T>&A,LinkList<T>&B)
    //A∩B=A
     {
         //LinkList<T> C;
        T temp;
        int i;
    
        for(i=1;i<=A.Length();i++)
        {
            temp=A.Get(i);
            if(B.Locate(temp)==0){A.Delete(i);i--;}
        }
        //return C;
     }
     template <typename T>
    void  DifferenceSet(LinkList<T>&C,LinkList<T>&A,LinkList<T>&B)
    //A-B=c
     {
        //LinkList<T> C;
        T temp;
        int i;
    
        for(i=1;i<=A.Length();i++)
        {
            temp=A.Get(i);
            C.Insert(C.Length()+1,temp);
        }
        for(i=1;i<=B.Length();i++)
        {
            temp=B.Get(i);
            if(A.Locate(temp)!=0){
                int pos=C.Locate(temp);
                C.Delete(pos);}
        }
        //return C;
     }
    int main( )
    {
        int ra[ ]={1,2,3,4,5};
        LinkList <int> A(ra,5);     //根据数组创建单链表
        cout<<"链表A中的元素为:"<<endl;
        A.PrintList();            //输出单链表a所有元素
        int rb[ ]={2,0,9,3,5};
        LinkList <int> B(rb,5);     //根据数组创建单链表
        cout<<"链表B中的元素为:"<<endl;
        B.PrintList();
    
        //UnionSet(a,b);
        //UnionSet1(a,b);
        //a=UnionSet2(a,b);
        //cout<<"链表a中的元素为:"<<endl;
        //a.PrintList();            //输出单链表a所有元素
        //b.PrintList();
        LinkList<int>C;
         UnionSet(C,A,B);
         cout<<"A∪B=";C.PrintList();
         LinkList<int>D;
         IntersectionSet(D,A,B);
         cout<<"A∩B=";D.PrintList();
         LinkList<int>E;
         DifferenceSet(E,A,B);
         cout<<"A-B=";E.PrintList();
         IntersectionSet1(A,B);
         cout<<"A∩B=";A.PrintList();
         return 0;
    }


     

    展开全文
  • 数据结构课程设计报告及代码--单链表实现的集合交
  • #include&amp;amp;lt;stdio.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; #define SET struct set ...//创建集合的链表 void Print_SetList(SET *head); //输出链表 void Sor...
        我是一个菜鸟本科生,第一次写博客,排版有些乱,
        主要是想通过博客记录自己的一些学习数据结构的经过与心得感受,
        和正在学习数据结构的小哥哥们一起交流分享。
       用单链表实现集合的判等,交,并,差,基本涉及到了单链表常用的一些操作,
       如建表,插入,删除,遍历,都不算太难。
       首先建表,在建表的过程中,将集合中的元素存入到了链表中,单此时的链表中的元素是无序的,
       在函数Sort_SetList(SET *head)中将链表的头节点作为实参传递到函数的形参中,
       采用冒泡排序的方法交换节点的数据域中的值,实现链表中的元素从小到大的排序。
       在判断两个集合是否相等时,分别将集合所对应的两个链表的头指针传递到判等函数的形参中,
       由于此时集合所对应的单链表时有序的,所以只要同步扫描两个单链表,若从头至尾每个对应的元素都相等,则判等函数返回真,否则返回假。
       在求两个集合的交集时,我开辟了新的内存空间,另建了一个单链表。
    
    #include<stdio.h>
    #include<stdlib.h>
    #define SET struct set
    struct set
    {
    	int number;
    	SET *next;
    };
    SET *Creat_SetList(char *name);//创建集合的链表
    void Print_SetList(SET *head); //输出链表
    void Sort_SetList(SET *head);  //集合排序
    bool Equal_Set(SET *head_A, SET *head_B);//判断集合是否相等
    SET *Intersection_Set(SET *head_A, SET *head_B);//求两个集合的交集
    SET *Union_Set(SET *head_A, SET *head_B);  //求两个集合的并集
    SET *Difer_Set(SET *head_A, SET *head_B);  //求两个集合的差集
    int  main()
    {
    	int n;
    	bool is;
    	SET *Set_A, *Set_B,*Set;
    	Set_A=Creat_SetList("A");
    	Set_B=Creat_SetList("B");
    	printf("\n集合A的元素为:");
    	Print_SetList(Set_A);
    	printf("\n集合B的元素为:");
    	Print_SetList(Set_B);
    	Sort_SetList(Set_A);
    	Sort_SetList(Set_B);
    	printf("\n排序之后集合A的元素为:");
    	Print_SetList(Set_A);
    	printf("\n排序之后集合B的元素为:");
    	Print_SetList(Set_B);
    	while (true)
    	{
    		printf("\n1.判断两个集合是否相等\n");
    		printf("2.求两个集合的交集\n");
    		printf("3.求两个集合的并集\n");
    		printf("4.求两个集合的差\n");
    		printf("5.退出系统\n");
    		scanf_s("%d", &n);
    		switch (n)
    		{
    		case 1: 
    			is = Equal_Set(Set_A, Set_B);
    			if (is == true)
    				printf("两个集合相等\n");
    			else
    				printf("两个集合不相等\n");
    			break;
    		case 2:
    			Set = Intersection_Set(Set_A, Set_B);
    			printf("\n两个集合的交集为:");
    			Print_SetList(Set);
    			break;
    		case 3:
    			Set = Union_Set(Set_A, Set_B);
    			Sort_SetList(Set);
    			printf("\n两个集合的并集为:");
    			Print_SetList(Set);
    			break;
    		case 4:
    			Set = Difer_Set(Set_A, Set_B);
    			printf("\n两个集合的差集为:");
    			Print_SetList(Set);
    			break;
    		case 5:
    			goto exit;
    			break;
    		default:
    			break;
    		}
    	}
    exit:
    	return 0;
    }
    SET *Creat_SetList(char *name)//创建集合的链表
    {
    	SET *head, *tail, *new_Node;
    	head = (SET *)malloc(sizeof(SET));
    	new_Node = (SET *)malloc(sizeof(SET));
    	printf("请输入集合%s的元素,以-1为结束标志:",name);
    	scanf_s("%d", &new_Node->number);
    	head->next = new_Node;
    	tail = new_Node;
    	while (true)
    	{
    		new_Node = (SET *)malloc(sizeof(SET));
    		scanf_s("%d", &new_Node->number);
    		if (new_Node->number == -1)
    			break;
    		tail->next = new_Node;
    		tail = new_Node;
    	}
    	tail->next = NULL;
    	return head;
    }
    void Print_SetList(SET *head) //输出链表
    {
    	SET *p = head->next;
    	while (p != NULL)
    	{
    		printf("%d  ", p->number);
    		p = p->next;
    	}
    }
    void Sort_SetList(SET *head)  //集合从小到大排序
    {
    	SET *p = head->next;
    	SET *end=NULL,*pre=NULL;
    	while (p->next != NULL)
    	{
    		p = p->next;
    	}
    	end = p;
    	while (head->next != end)
    	{
    		p = head->next;
    		while (p != end)
    		{
    			if (p->number > p->next->number)
    			{
    				int temp = p->number;
    				p->number = p->next->number;
    				p->next->number = temp;
    			}
    			pre = p;
    			p = p->next;
    		}
    		end = pre;
    	}
    }
    bool Equal_Set(SET *head_A, SET *head_B)//判断集合是否相等
    {
    	SET *pa = head_A->next, *pb = head_B->next;
    	while (pa != NULL&&pb != NULL)
    	{
    		if (pa->number != pb->number)
    		{
    			return false;
    		}
    		pa = pa->next;
    		pb = pb->next;
    	}
    	if (pa == NULL&&pb == NULL)
    	{
    		return true;
    	}
    	else 
    	{
    		return false;
    	}
    }
    SET *Intersection_Set(SET *head_A, SET *head_B)//求两个集合的交集
    {
    	SET *pa = head_A->next, *pb = head_B->next;
    	SET *begin = NULL, *end = NULL,*new_Node=NULL;
    	begin = (SET *)malloc(sizeof(SET));
    	begin->next = NULL;
    	while (pa != NULL&&pb != NULL)
    	{
    		if (pa->number < pb->number)
    		{
    			pa = pa->next;
    		}
    		else if(pa->number>pb->number)
    		{
    			pb = pb->next;
    		}
    		else
    		{
    			new_Node= (SET *)malloc(sizeof(SET));
    			new_Node->number = pb->number;
    			if (begin->next == NULL)
    			{
    				begin->next = new_Node;
    				end = new_Node;
    			}
    			else
    			{
    				end->next = new_Node;
    				end = new_Node;
    				
    			}
    			pa = pa->next;
    			pb = pb->next;
    		}
    	}
    	end->next = NULL;
    	return begin;
    }
    SET *Union_Set(SET *head_A, SET *head_B)  //求两个集合的并集
    {
    	SET *pa = head_A->next, *pb = head_B->next;
    	SET *begin = NULL, *end = NULL, *new_Node;
    	begin = (SET *)malloc(sizeof(SET));
    	begin->next = NULL;
    	while (pa != NULL)
    	{
    		new_Node = (SET *)malloc(sizeof(SET));
    		new_Node->number = pa->number;
    		if (begin->next == NULL)
    		{
    			begin->next = new_Node;
    			end = new_Node;
    		}
    		else 
    		{
    			end->next = new_Node;
    			end = new_Node;
    			end->next = NULL;
    		}
    		pa = pa->next;
    	}
    	pa = begin->next;
    	while (pb != NULL)
    	{
    		while (pa != NULL)
    		{
    			if (pb->number == pa->number)
    				break;
    			pa = pa->next;
    		}
    		if (pa == NULL)
    		{
    			pa = begin->next;			
    			new_Node = (SET *)malloc(sizeof(SET));
    			new_Node->number = pb->number;
    			begin->next = new_Node;
    			new_Node->next = pa;
    		}
    		pa = begin->next;
    		pb = pb->next;
    	}
    	return begin;
    }
    SET *Difer_Set(SET *head_A, SET *head_B)  //求两个集合的差集
    {
    	SET *pa = head_A->next,*pare=head_A, *pb = head_B->next;
    	while (pa != NULL)
    	{
    		while (pb != NULL)
    		{
    			if (pa->number == pb->number)
    			{
    				pare->next = pa->next;
    			}			
    			pb = pb->next;
    		}
    		pb = head_B->next;
    		pare = pa;
    		pa = pa->next;
    	}
    	return head_A;
    }
    
    展开全文
  • 利用带头结点的单链表实现两个集合的并运算 1.题目重述 2.题目功能描述 3. 概要设计图 4. 程序源代码及注释 5. 流程图 6. 截图与数据分析 7.所采用的存储结构的优缺点及采用理由 8.实验心得体会
  • 问题描述:用有序单链表表示集合,实现集合的交运算 基本要求: 空间复杂度为 O(1) 系统功能模块 4.1输出和销毁函数设计 void DispList(LinkList*L) { LinkList *p=L->next; while(p!=NULL) { ...

    二、课程设计内容及要求

    集合的交、并和差运算的实现
    问题描述:用有序单链表表示集合,实现集合的交、并、差运算
    基本要求: 空间复杂度为 O(1)

    系统功能模块
    在这里插入图片描述
    在这里插入图片描述
    4.1输出和销毁函数设计
    void DispList(LinkList*L)
    {
    LinkList *p=L->next;
    while(p!=NULL)
    {
    cout<<"%c “,p->data;
    p=p->next;
    }
    cout<<”\n";
    }
    void DestroyList(LinkList &L)
    {
    LinkList
    p=L->next,*pre=L;
    while(p!=NULL)
    {
    free(pre);
    pre=p;
    p=pre->next;
    }
    free(pre);
    }
    4.2尾插法建立单链表设计流程图
    P

    L1
    4.3有序单链表算法设计分析
    有序表中的操作要充分利用线性表的有序性。在一个有序单链表中插入一个元素值为小的结点,使插入后单链表任然有序。分析:先建立一个带插入结点,然后依次与单链表中各结点的数据域比较大小,找到该结点的插入位置,最后插入该结点。
    思路流程图:(P指向L的第二个数据结点,构造有序表只含一个数据结点。)

    4.4主要功能的代码详细设计
    4.4.1实现集合A和集合B的并集
    void Union(LinkList ha,LinkListhb,LinkList*&hc)
    {
    LinkList *pa=ha->next,*pb=hb->next,*pc,s;
    hc=new LNode;
    pc=hc;
    while(pa!=NULL &&pb!=NULL )
    {
    if(pa->datadata)
    {
    s=new LNode;
    s->data=pa->data;
    pc->next=s;
    pc=s;
    pa=pa->next;
    }
    else if(pa->data>pb->data)
    {
    s=new LNode;
    s->data=pb->data;
    pc->next=s;
    pc=s;
    pb=pb->next;
    }
    else{
    s=new LNode;
    s->data=pa->data;
    pc->next=s;
    pc=s;
    pa=pa->next;
    pb=pb->next;
    }
    }
    if(pb!=NULL)
    pa=pb;
    while(pa!=NULL)
    {
    s=new LNode;
    s->data=pa->data;
    pc->next=s;
    pc=s;
    pa=pa->next;
    }
    pc->next=NULL;
    }
    4.4.2实现集合A和集合B的交集
    void InterSect(LinkList ha,LinkListhb,LinkList
    &hc)
    {
    LinkList *pa=ha->next,*pb,*pc,s;
    hc=new LNode;
    pc=hc;
    while(pa!=NULL)
    {
    pb=hb->next;
    while(pb!=NULL&&pb->datadata)
    pb=pb->next;
    if(pb!=NULL &&pb->data==pa->data)//B节点在A节点中复制A节点
    {
    s=new LNode;
    s->data=pa->data;
    pc->next=s;
    pc=s;
    }
    pa=pa->next;
    }
    pc->next=NULL;
    }
    4.4.3实现集合A和集合B的差集
    void Subs(LinkList ha,LinkListhb,LinkList
    &hc)
    {
    LinkList *pa=ha->next,*pb,*pc,*s;
    hc=new LNode;
    pc=hc;
    while(pa!=NULL)
    {
    pb=hb->next;
    while(pb!=NULL&&pb->datadata)
    pb=pb->next;
    if(!(pb!=NULL &&pb->data==pa->data))///B节点不在A节点中复制A节点
    {
    s=new LNode;
    s->data=pa->data;
    pc->next=s;
    pc=s;
    }
    pa=pa->next;
    }
    pc->next=NULL;
    }
    4.5主函数测试详细设计
    int main()
    {
    LinkList *ha,*hb,*hc;
    int n,k;
    while(1)
    {
    cout<<"\n\t\t —集合的简单运算—\n\n";
    cout<<"\t\t\t 菜单 \n";
    cout<<"\t\t\t ——— ————— ——\n";
    cout<<"\t\t\t 1. 请输入A集合个数与A集合的元素 \n";
    cout<<"\t\t\t 2. 请输入B集合个数与B集合的元素 \n";
    cout<<"\t\t\t 3. A集合的有序集合 \n";
    cout<<"\t\t\t 4. B集合的有序集合 \n";
    cout<<"\t\t\t 5. AB集合的并集 \n";
    cout<<"\t\t\t 6. AB集合的交集 \n";
    cout<<"\t\t\t 7. AB集合的差集 \n";
    cout<<"\t\t\t 8. 退出 \n";
    cout<<"\t\t\t ———————————\n";
    cout<<"\t\t\t 请选择(1-8):";
    cin>>k;
    switch(k)
    {
    case 1: cout<<“请输入A集合的个数与A集合元素:”;
    cin>>n;
    CreateList_L1(ha,n);break;
    case 2:cout<<“请输入B集合的个数与B集合元素”;
    cin>>n;
    CreateList_L1(hb,n); break;
    case 3:sort(ha);cout<<"\n A的有序集合为:";
    DispList(ha);break;
    case 4:sort(hb);cout<<"\n B的有序集合为:";
    DispList(hb);break;
    case 5:Union(ha,hb,hc);cout<<"\n AB集合的并集为:";
    DispList(hc);break;
    case 6:InterSect(ha,hb,hc);cout<<"\n AB集合的交集为:";
    DispList(hc);break;
    case 7:Subs(ha,hb,hc);cout<<"\n AB集合的差集为:";
    DispList(hc);break;
    case 0: cout<<"\n\t\t\t------ 谢谢使用!-------\n";
    cout<<"\n\t\t\t按任意键退出…\n";
    return 0;
    }
    }
    DestroyList(ha);
    DestroyList(hb);
    DestroyList(hc);
    return 0;
    }
    5调试分析:
    调试程序中出现的问题出现了错误,先掌握molloc函数的用法,利用molloc函数在申请新的内存时,当无法知道内存具体位置时,想要绑定真正的内存空间,就会利用到molloc函数。改正错误,直接用new来创建一个新的结点(例如:s=new LNode)

    改正错误,直接用new来创建一个新的结点(例如:s=new LNode;)调试程序合适。

    6用户使用说明:
    功能序号 菜单功能
    1 输入集合A的个数和元素
    2 输入集合B的个数和元素
    3 A集合排序
    4 B集合排序
    5 AB集合的并集
    6 AB集合的交集
    7 AB集合的差集
    8 退出

    数据结构实验报告目录

    在这里插入图片描述

    展开全文
  • 西安建筑科技大学华清学院 课程设计论文 题 目 院 系 专业班级 计算机 姓 学 名 号 指导教师 2016 年 9 月 8 日 一课程设 一课程设计论文题目 集合运算 使用链表来表示集合完成集合的合并求交集等操作 二本次课程...
  • /*在以单链表表示的正整数的有序集合上,实现集合的并运算。 基本要求: (1)用单链表存储集合中的数据; (2)对单链表中的数据进行排序。 */ #include #include #include typedef struct LNode{ int ...
  • 使用C++单链表集合进行交并差运算,并可以从文件读取,保留结果至文件
  • 集合的交、运算的实现...用有序单链表表示集合,实现集合的交运算。对集合中的元素,用有序单链表进行存储。实现交、运算时,不另外申请存储空间。充分利用单链表的有序性,算法有较好的时间性能。
  • 数据结构实习的作品,可以运行的~用相应函数实现集合的交并差运算,以单链表的形式实现,可行性良好
  • 因为准备考研,在学校学了两个星期数学,回家休息顺便写了这个程序,题目是有位朋友在blogs里留言出: 编写一个... 我也不知道例2.4算法是什么,但我这段程序实现交并差的功能,而且结果也保持排序。 还有,...
  • 至少应包括初始化,用尾插法建立集合,查找给定元素是否在集合内,将新元素插入集合中,删除集合中指定元素,求两个集合的并、输出等操作的实现。 要求设计一个主程序,首先定义3个用有序单链表实现的集合A...
  • 集合的交并差 c++写的 源代码

    热门讨论 2011-01-05 19:41:35
    该源代码描述了集合的交并差运算方法,经过严格测试,能正确运行。运用单链表,用人机交互的方式实现,需要的可以去下载。
  • 本课程设计主要解决的是集合相关运算的研究与实现,对待求解问题建立模型,设计合理的数据结构。采用有序单链表表示集合,实现集合的交运算,通过设计高效的算法实现。所有的代码用C++实现
  • 本程序采用单链表的存储结构,实现集合运算,不另外申请存储空间,现在大二刚学数据结构!望指点!
  • 集合的并运算

    千次阅读 2016-01-15 17:21:14
    在以单链表表示的正整数的有序集合上,实现集合的并运算。 基本要求: (1)用单链表存储集合中的数据; (2)对单链表中的数据进行排序。 测试数据要求: 数据中包含的整数,是随机产生的两位整数 #...
  • 例如A={2,7,9} ,B={3,7,12,2},则集合的C=A∪B={2,7,9,3,12},而集合的交 C=A∩B={2,7},集合的C=A-B={9}。集合A和B中元素个数在1~100之间。 输入格式: 三行,第一行分别为集合A,B的个数...
  • 一题目要求 用Java语言实现单链表的基本操作并实现集合的交并运算 二程序功能定义 1输出两个集合的交集即找出两个集合的相同元素 2输出两个集合的并集即把两个集合的全部元素不重复的加起来 3输出两个集合的差集...
  • 有两个字符集合A和B,现在要求实现集合的并运算。 要求:集合用单链表表示,假设同一个集合中不存在重复的元素。A、B集合元素最多不超过100个,至少有一个元素。 算法实现: 1)将两个集合的元素按递增方式...
  • 整数集合用单链表实现存储,实现如下操作: (1) 初始化集合 (2)插入一个数到集合指定位置 (3)按值删除集合中的元素 (4)按值在集合中进行查找 (5)清空集合 (6)求两个集合的交集 (7)求两个集合的并集 ...
  • 优质解答以下程序由标准C实现,经严格测试.程序通过单链表存储集合#include#includetypedef struct pointer{char dat;struct pointer *link;} pointer;void readdata(pointer *head){ //读集合pointer *p;char tmp;...
  • 2014年 10月 31日     ...实验三 约瑟夫环和集合的相关运算的设计和实现 ...一....利用线性表实现约瑟夫环和集合的判等、...2.用有序单链表实现集合的判等、的运算(即实验课本P180设计实验中的
  • 数据结构 集合运算链表实现

    千次阅读 2018-04-15 18:10:52
     2 实验内容实现集合(用单链表表示)的并运算,在此基础上设计一个主程序完成以下功能:(1) 初始化集合A{'c','a','e','h'}、B{'f','h','b','g','d','a'}和空集合C(2) 分别创建三个链...
  • 请设计实现集合类,元素类型为整形, 集合采用带头结点单链表表示。该集合类成员函数须支持集合元素增加、删除、查询、显示,支持集合并、运算,运算结果要求返回集合对象(否则每项扣2分);利用你设计...
  • 集合的并运算。用有序单链表表示。 #pragma once // //aggregate.h //集合运算;有序单链表实现 //2013-9-4 23:41 // typedef int element; typedef struct LNode { element data; LNode* next; }...
  • ⑹ 设计一个菜单,具有输入集合元素、求集合A、B的交C、求集合A、B的D、求集合A与B的对称E、退出等基本的功能。 3.测试数据:字符型和整形由同学们自定,但集合A、B的元素个数不得少于15个。
  • 利用带头结点的单链表实现两个集合的并运算。(难易程度:低) [实验目的] 1、掌握线性表的链表存储结构。 2、掌握在单链表上基本操作的实现。 3、在掌握单链表的基本操作上进行综合题的实现。 [实验...

空空如也

空空如也

1 2
收藏数 34
精华内容 13
关键字:

单链表实现集合的交并差