OJ：集合合并

最新推荐文章于 2023-08-28 13:36:54 发布

风范1997

最新推荐文章于 2023-08-28 13:36:54 发布

阅读量597

点赞数

文章标签：开发语言数据结构算法 c++

本文链接：https://blog.csdn.net/m0_70232279/article/details/127505468

版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

题目叙述
代码

题目叙述

总时间限制:

3000ms

内存限制:

50000kB

描述

已知集合A与集合B，且第个集合内数据是唯一的。求A，B集合合并成新的集合C，要求C集合内的数据也是唯一的。并指出C集合的个数。

输入

三行，第一行分别为集合A，B的个数
第二行为A集合的数据
第三行为B集合的数据

输出

两行
第一行集合C的个数
第二行为C集合的数据

样例输入

4 5
12 34 56 78
34 67 89 34 76

样例输出

7
12 34 56 78 67 89 76

提示

数据小于30000

提示：以下是本篇文章正文内容，下面案例可供参考

代码

#include <iostream>
#include <cstdlib>
using namespace std;
//cout<<l.head2是显示l.head2的地址
//cout<<l.head2->data是显示head2->data的值
//cout<<l.head2->next是显示head2->next的地址
class Node {//节点定义
public:
   int data;//数据域
   class Node* next;//指针域
   class Node* pre;//vious
};
class LinkList {
public:
   LinkList() {//初始化
       head = new Node;//new（新建）一个头节点
       head->data = 0;//因为定义head时用的是Node自定义类型，
       //因此有数据域，有指针域，data先定义为0，后面插入数据时更改，next同理
       head->next = nullptr;

       head1 = new Node;//new（新建）一个头节点
       head1->data = 0;//因为定义head时用的是Node自定义类型，
       //因此有数据域，有指针域，data先定义为0，后面插入数据时更改，next同理
       head1->next = nullptr;

       head2 = new Node;//new（新建）一个头节点
       head2->data = 0;//因为定义head时用的是Node自定义类型，
       //因此有数据域，有指针域，data先定义为0，后面插入数据时更改，next同理
       head2->next = nullptr;

       head3 = new Node;//new（新建）一个头节点
       head3->data = 0;//因为定义head时用的是Node自定义类型，
       //因此有数据域，有指针域，data先定义为0，后面插入数据时更改，next同理
       head3->next = nullptr;
       head3->pre = nullptr;
   }
   /*~LinkList() {//析构
       delete head;
       delete head1;
       delete head2;
       delete head3;
   }*/
   int CreatLinkList(int size);
   int GetLen();
   int GetlenForweicha();
   void JudgeZeng();
   void showLinkList();
   Node* Find(int data);
   Node* FindForweicha(int data1);
   Node* FindForweichaForDoubleLink(int data1);
   void touchaList();
   void weichaList();
   void weichaListForFour(int n);
   void anyList(int data, int n);
   void DeleteAnyList(int data);
   void DeleteHeadList();
   void FindRepeatForWeiCha();
   bool isEmpty();
   void DeleteAll();
   void DeleteAnyListForweicha(int data1);
   void DeleteHeadListForweicha();
   void DeleteZhiListForweicha(int data1);
   void CreatFLink();
   void DisfloatLink();
   void PlusLink(LinkList l1, LinkList l2, int a, int b);
   void weichaForDoubleLink();
   void CreatFLinkForDoubleLink();
   int GetlenForweichaForDoubleLink();
   void weichaForDoubleLinkForAnyElement();
   void DeleteAnyListForDoubleLink(int data);
   void DeleteHeadListForweichaForDoubleLink();
   void DeleteZhiListForweichaForDoubleLink(int data1);
   void showLinkListForDoubleLink();
   void PlusLinkForSix(LinkList l1, LinkList l2, int a, int b);
   void showLinkListForWeiCha();
private:
   Node* head;//头指针
   Node* head1;
   Node* head2;
   Node* temp;
   Node* head3;//双向
};

int LinkList::GetlenForweicha() {
   int size = 0;
   Node* p = head2->next;//定义一个新指针，指向头节点的next
   //（next是第一个，头节点不算）
   //*p =的是next的值，head是=&next，(head->next==Node.next)
   while (p != nullptr) {
       size++;
       p = p->next;
   }
   return size;

}
int LinkList::GetlenForweichaForDoubleLink() {
   int size = 0;
   Node* p = head3->next;//定义一个新指针，指向头节点的next
   //（next是第一个，头节点不算）
   //*p =的是next的值，head是=&next，(head->next==Node.next)
   while (p != nullptr) {
       size++;
       p = p->next;
   }
   return size;

}
//共三种创建链表方法

void LinkList::weichaListForFour(int n)
{
   int data1 = 1;
   for (int i = 1; i <= n; i++)
   {
       cin >> data1;
       Node* newNode = new Node;//先定义一个Node节点指针newNode
       newNode->next = nullptr;//定义newNode的数据域和指针域
       newNode->data = data1;
       Node* p = head2;
       if (head2 == nullptr) {
           head2 = newNode;
       }
       while (p->next != nullptr)
       {
           p = p->next;//次循环结束后，p即为插入前的最后一个节点
       }
       p->next = newNode;

}

}
void LinkList::PlusLink(LinkList l1, LinkList l2, int a, int b) {//将两个链表l1，l2中不重复的元素赋值给l3
   int arr[100];
   Node* p1 = l1.head2;
   Node* p2 = l2.head2;

   for (int i = 1; i <= a; i++) {//给数组赋值l1
       arr[i] = p1->next->data;
       p1 = p1->next;
   }
   for (int i = a + 1; i <= a + b; i++) {//给数组赋值l2
       arr[i] = p2->next->data;
       p2 = p2->next;
   }
   int sum = a + b;//sum最终为具体有几个不同元素
   for (int i = 1; i <= sum; i++) {//找出重复元素的序号
       for (int j = i + 1; j <= sum; j++) {
           if (arr[i] == arr[j]) {
               for (int k = j; k < sum; k++)//
               {
                   arr[k] = arr[k + 1];//把arr[3]=arr[4],arr[4]=arr[5]等等，覆盖前面的值。
                                   //当找到arrr[2]与arr[3]相同值时,
                               //arr[3]后的所有值都覆盖前面一个值。
               }
               sum--;//为什么要n--？1是因为覆盖了前面的值，后面的值就不需要显示了。2是为了数组被少了一个元素了。
               j--;//为什么要j--？新值（刚被覆盖的值arr[3]=4）还没有比较。
               //减了之后，上去循环会再加1，那么它还是3，还是会把新值重新比较

           }
       }
   }

   cout << sum << endl;
   for (int i = 1; i <= sum; i++) {
       Node* newNode3 = new Node;//先定义一个Node节点指针newNode
       newNode3->next = nullptr;//定义newNode的数据域和指针域
       newNode3->data = arr[i];
       Node* p = head2;
       if (head2 == nullptr) {
           head2 = newNode3;
       }
       while (p->next != nullptr)
       {
           p = p->next;//次循环结束后，p即为插入前的最后一个节点
       }
       p->next = newNode3;

}

void LinkList::PlusLinkForSix(LinkList l1, LinkList l2, int a, int b)
{
   int arr[100];
   Node* p1 = l1.head2;
   Node* p2 = l2.head2;

           }
       }
   }

   }
};
void LinkList::showLinkListForWeiCha() {//遍历函数
   if (head2 == nullptr && head2->next == nullptr) {
       cout << "空" << endl;
   }

   Node* p1 = head2;
   do {
       p1 = p1->next;
       cout << p1->data << " ";
   } while (p1->next != nullptr);
   cout << endl;
}

void Six() {
   int i, j;
   int zhi, place;
   LinkList l1;
   LinkList l2;
   LinkList l3;
   cin >> i >> j;
   l1.weichaListForFour(i);
   l2.weichaListForFour(j);
   l3.PlusLink(l1, l2, i, j);
   l3.showLinkListForWeiCha();

}
int main() {

Six();

return 0;
}