C++程序设计实践指导1.5求两个整数集合并集改写要求实现

改写要求1:改写为单链表结构可以对任意长度整数集合求并集

#include <cstdlib>
#include <iostream>

using namespace std;
struct LinkNode
{
  int data;
  LinkNode* next;
};
class SET
{
      public:
             struct LinkNode* creat(int x[],int len);
             struct LinkNode* copy(LinkNode* aHead);
             int notin(int elem,LinkNode* cHead)
             {
                 LinkNode* p;
                 p=cHead;
                 while(p)
                 {
                         if(elem==p->data)
                         return 0;
                         p=p->next;
                 }
                 return 1;
             }

             void insert(LinkNode* bHead,LinkNode* cHead);
             void output(LinkNode* cHead)
             {
                  LinkNode* p=cHead->next;
                  while(p)
                  {
                          cout<<p->data<<"\t";
                          p=p->next;
                  }
                  cout<<endl;
             }
};

struct LinkNode* SET::creat(int x[],int len)
{
       LinkNode* pHead=new LinkNode;
       pHead->next=NULL;
       LinkNode* p;
       p=pHead;
       for(int i=0;i<len;i++)
       {
             LinkNode* newLinkNode=new LinkNode;
             newLinkNode->next=NULL;
             newLinkNode->data=x[i];
             p->next=newLinkNode;
             p=newLinkNode;
       }
       return pHead;
}

struct LinkNode* SET::copy(LinkNode* aHead)
{
     LinkNode* cHead=new LinkNode;
     cHead->next=NULL;
     LinkNode* p,*r;
     p=aHead->next;
     r=cHead;
     while(p)
     {
             LinkNode* newLinkNode=new LinkNode;
             newLinkNode->next=NULL;
             newLinkNode->data=p->data;
             p=p->next;
             r->next=newLinkNode;
             r=newLinkNode;
     }
     return cHead;
}

void SET::insert(LinkNode *bHead,LinkNode* cHead)
{

     LinkNode* q,*s,*t;
     q=bHead->next;
     s=cHead->next;
     while(s)
     {
             t=s;
             s=s->next;
     }
    while(q)
     {
             if(notin(q->data,cHead)!=0)
             {
                 LinkNode* newLinkNode=new LinkNode;
                 newLinkNode->next=NULL;
                 newLinkNode->data=q->data;
                 t->next=newLinkNode;
                 t=newLinkNode;
             }
             q=q->next;
     }

}

int main(int argc, char *argv[])
{
    int s1[]={1,3,5,7,9};
    int s2[]={1,2,3,4,5,6};
    LinkNode* aHead,*bHead,*cHead,*Head;
    SET set;
    aHead=set.creat(s1,sizeof(s1)/sizeof(s1[0]));
    bHead=set.creat(s2,sizeof(s2)/sizeof(s2[0]));
    cHead=set.copy(aHead);
    set.insert(bHead,cHead);
    set.output(cHead);
    system("PAUSE");
    return EXIT_SUCCESS;
}

改写要求2:对任意长度的两个整数集合求交集

#include <cstdlib>
#include <iostream>

using namespace std;
struct LinkNode
{
  int data;
  LinkNode* next;
};
class SET
{
      public:
             struct LinkNode* creat(int x[],int len);
             struct LinkNode* copy(LinkNode* aHead);
             int notin(int elem,LinkNode* cHead)
             {
                 LinkNode* p;
                 p=cHead;
                 while(p)
                 {
                         if(elem==p->data)
                         return 1;
                         p=p->next;
                 }
                 return 0;
             }

             struct LinkNode* insert(LinkNode* bHead,LinkNode* cHead);
             void output(LinkNode* cHead)
             {
                  LinkNode* p=cHead->next;
                  while(p)
                  {
                          cout<<p->data<<"\t";
                          p=p->next;
                  }
                  cout<<endl;
             }
};

struct LinkNode* SET::creat(int x[],int len)
{
       LinkNode* pHead=new LinkNode;
       pHead->next=NULL;
       LinkNode* p;
       p=pHead;
       for(int i=0;i<len;i++)
       {
             LinkNode* newLinkNode=new LinkNode;
             newLinkNode->next=NULL;
             newLinkNode->data=x[i];
             p->next=newLinkNode;
             p=newLinkNode;
       }
       return pHead;
}

struct LinkNode* SET::copy(LinkNode* aHead)
{
     LinkNode* cHead=new LinkNode;
     cHead->next=NULL;
     LinkNode* p,*r;
     p=aHead->next;
     r=cHead;
     while(p)
     {
             LinkNode* newLinkNode=new LinkNode;
             newLinkNode->next=NULL;
             newLinkNode->data=p->data;
             p=p->next;
             r->next=newLinkNode;
             r=newLinkNode;
     }
     return cHead;
}

struct LinkNode* SET::insert(LinkNode *bHead,LinkNode* cHead)
{

     LinkNode* q,*t;
     LinkNode* Head=new LinkNode;
     q=bHead->next;
     Head->next=NULL;
     t=Head;
    while(q)
     {
             if(notin(q->data,cHead)!=0)
             {
                 LinkNode* newLinkNode=new LinkNode;
                 newLinkNode->next=NULL;
                 newLinkNode->data=q->data;
                 t->next=newLinkNode;
                 t=newLinkNode;
             }
             q=q->next;
     }
     return Head;
}

int main(int argc, char *argv[])
{
    int s1[]={1,3,5,7,9};
    int s2[]={1,2,3,4,5,6};
    LinkNode* aHead,*bHead,*cHead,*Head;
    SET set;
    aHead=set.creat(s1,sizeof(s1)/sizeof(s1[0]));
    bHead=set.creat(s2,sizeof(s2)/sizeof(s2[0]));
    cHead=set.copy(aHead);
    Head=set.insert(bHead,cHead);
    set.output(Head);
    system("PAUSE");
    return EXIT_SUCCESS;
}
时间: 2024-10-14 14:53:22

C++程序设计实践指导1.5求两个整数集合并集改写要求实现的相关文章

C++程序设计实践指导1.3求任意整数降序数改写要求实现

改写要求1:动态生成单链表存储 #include <cstdlib> #include <iostream> using namespace std; struct LinkNode { int data; struct LinkNode *next; }; class NUM { int n; public: NUM(int x) { n=x; } struct LinkNode * descrease(); void show(LinkNode* pHead) { LinkNo

C++程序设计实践指导1.6超长数列中n个数排序改写要求实现

改写要求1:将以上程序改写为适合超长整数 改写要求2:将以上程序改写为适合超长数列 改写要求3:将数列中指定位置m开始的n个结点重新按降序排序 改写要求4:输出指定位置m开始的n个结点的超长整数 #include <cstdlib> #include <iostream> #include <string> using namespace std; struct LongIntegerNode { short int data; LongIntegerNode *nex

C++程序设计实践指导1.1删除序列中相同的数改写要求实现

改写要求1:改写为以指针为数据结构 #include <iostream> #include <cstdlib> using namespace std; class ARP { int m; int* p; int count[10]; public: ARP(int x[],int size) { m = size; p = new int [m]; for (int i =0;i<m;i++) { p[i]=x[i]; } for (int i =0;i<m;i+

C++程序设计实践指导1.2二维数组的操作运算改写要求实现

改写要求1:改写为以单链表表示二维数组 #include <cstdlib> #include <iostream> using namespace std; struct LinkNode { int Row; int Column; int Data; LinkNode *next; }; class MATRIX { int m; int sum; public: struct LinkNode* creat(int x[][40],int k) { m=k; LinkNod

求两个整数集合的交集

这里要用到C++-STL中的set容器,这个容器的特点就是去重! 设计测试:给定两个集合 a[] = {1,2,3,4,5,6}; b[] = {4,5,6,7,8,9}; 则集合的交集为4,5,6 代码如下,仅供参考: 1 #include <iostream> 2 #include <cstdio> 3 #include <cstdlib> 4 #include <set> 5 #define M 6 6 #define N 6 7 using name

求两个整数的最大公约数

<C和指针>第7章第2道编程题: 两个整型值M和N(M.N均大于0)的最大公约数可以按照下面的方法计算: 请编写一个名叫gcd的函数,它接受两个整型参数,并返回这两个数的最大公约数.如果这两个参数中的任何一个不大于零,函数返回零. 1 /* 2 ** 求两个整数的最大公约数 3 */ 4 5 #include <stdio.h> 6 7 int gcd( int M, int N ); 8 9 int 10 main() 11 { 12 int m, n; 13 scanf( &q

欧几里得算法求两个整数的最大公因数

unsigned int Gcd (unsigned int m,unsigned int n){ unsigned int rem; while(n>0){ rem = m % n; m = n; n = rem; } return m; } 对于m<n的情况,第一次循环m,n会交换 算法的时间复杂度计算 时间复杂度 logn 若M > N,则第一次循环交换M和N. 若想分析其时间复杂度,则要求循环次数,即生成余数的次数. 可以证明: 当M > N, 则M % N < M

12_1求两个整数中的较小值,要求不能使用比较运算符, if-else, a&gt;b?a:b, while for

转载请注明出处:http://www.cnblogs.com/wuzetiandaren/p/4253932.html  声明:现大部分文章为寻找问题时在网上相互转载,此博是为自己做个记录记录,方便自己也方便有类似问题的朋友,本文的思想也许有所借鉴,但源码均为本人实现,如有侵权,请发邮件表明文章和原出处地址,我一定在文章中注明.谢谢. 题目:求两个整数中的较小值,要求不能使用比较运算符, if-else, a>b?a:b, while for, 内嵌汇编递归第三方函数. 在网上看到一些网友给出了

A、B两个整数集合,设计一个算法求他们的交集

代码留作记录,本人水平有限,看了别人的解法真是自愧不如. 关于此题的详细探讨可以参考:http://blog.csdn.net/thebestdavid/article/details/12056293 /*A.B两个整数集合,设计一个算法求他们的交集,尽可能的高效.*/ #include <iostream> #include <cstring> #include <set> #define M 8 #define N 5 using namespace std; i