用有序整数链表表示集合，求两个集合的和、差、交

最新推荐文章于 2024-07-18 00:08:52 发布
最新推荐文章于 2024-07-18 00:08:52 发布
阅读量94 收藏
点赞数 1
文章标签： 链表 数据结构 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuoer_GG/article/details/135176121
版权

问题描述：用有序整数链表表示整数集合（这里默认的是不带辅助表元的链表），编写已知两个集合求集合和（S=S1∪S2）、集合差（S=S1-S2）、集合交（S=S1∩S2）的函数。

这里的三种集合操作，我们都可以采用双指针历遍链表的方法。

求集合的并集，用双指针依次历遍，将比较的表元中较小者，放入新链表，如果相等，则放入其中一个（表元类型是Node*，creatNode为创建新表元的函数，将展示在完整代码中）。

Node* unionSets(Node* S1, Node* S2) {
    Node* result = NULL;//result为新链表头指针
    Node* tail = NULL;//新链表尾指针

    Node* currentS1 = S1;
    Node* currentS2 = S2;

    //双指针分别遍历S1和S2，直到其中一个被遍历完，按从小到大的顺序添加节点到结果中
    while (currentS1 != NULL && currentS2 != NULL) {
        if (currentS1->value < currentS2->value) {
            Node* newNode = createNode(currentS1->value);
            if (result == NULL) {
                result = newNode;
                tail = newNode;
            }
            else {
                tail->next = newNode;
                tail = newNode;
            }
            currentS1 = currentS1->next;
        }
        else if (currentS1->value > currentS2->value) {
            Node* newNode = createNode(currentS2->value);
            if (result == NULL) {
                result = newNode;
                tail = newNode;
            }
            else {
                tail->next = newNode;
                tail = newNode;
            }
            currentS2 = currentS2->next;
        }
        else {//比较的两者相同，插入其中的一个
            Node* newNode = createNode(currentS1->value);
            if (result == NULL) {
                result = newNode;
                tail = newNode;
            }
            else {
                tail->next = newNode;
                tail = newNode;
            }
            //相等时双指针均后移
            currentS1 = currentS1->next;
            currentS2 = currentS2->next;
        }
    }
    //对于s1，s2中剩下的表元（如果有）
    while (currentS1 != NULL) {
        Node* newNode = createNode(currentS1->value);
        if (result == NULL) {
            result = newNode;
            tail = newNode;
        }
        else {
            tail->next = newNode;
            tail = newNode;
        }
        currentS1 = currentS1->next;
    }

    while (currentS2 != NULL) {
        Node* newNode = createNode(currentS2->value);
        if (result == NULL) {
            result = newNode;
            tail = newNode;
        }
        else {
            tail->next = newNode;
            tail = newNode;
        }
        currentS2 = currentS2->next;
    }

    return result;
}

求集合的差（S1-S2），思路就是对于S2中的所有数，将S1中相等的元素删除，我们有两种实现方法，一是双指针依次历遍，将S1中比S2取出的表元较小者全部放入新表元，再将S1后移，如果相同，不插入，均后移（利用到了链表有序）。

Node* differenceSets(Node* S1, Node* S2) {
    Node* result = NULL;
    Node* tail = NULL;

    Node* currentS1 = S1;
    Node* currentS2 = S2;

    while (currentS1 != NULL && currentS2 != NULL) {
        //对于S2中的每一个节点值，添加S1中比其小的所有节点到结果中
        if (currentS1->value < currentS2->value) {
            Node* newNode = createNode(currentS1->value);
            if (result == NULL) {
                result = newNode;
                tail = newNode;
            }
            else {
                tail->next = newNode;
                tail = newNode;
            }
            currentS1 = currentS1->next;
        }
        else if (currentS1->value > currentS2->value) {
            currentS2 = currentS2->next;
        }
        else {
            currentS1 = currentS1->next;
            currentS2 = currentS2->next;
        }
    }

    while (currentS1 != NULL) {
        //添加S1剩余节点到结果中
        Node* newNode = createNode(currentS1->value);
        if (result == NULL) {
            result = newNode;
            tail = newNode;
        }
        else {
            tail->next = newNode;
            tail = newNode;
        }
        currentS1 = currentS1->next;
    }

    return result;
}

也还有二，依次历遍S2中的每一个数，再历遍S1查看是否有相同的元素，如果有，直接删去，这里就需要先复制链表S1。用到链表复制函数：

Node* copyList(Node* head) {
    if (NULL == head) {
        return NULL;
    }
    Node* newHead = createNode(head->value);
    Node* current = head->next;
    Node* newCurrent = newHead;
    while (current != NULL) {
        Node* newNode = createNode(current->value);
        newCurrent->next = newNode;
        newCurrent = newCurrent->next;
        current = current->next;
    }
    return newHead;
}

和删除特定表元的函数：

Node* delete(Node* head, int x)
{
    Node* w, * p;
    if (head == NULL)return NULL;
    p = head;
    w = head;
    while (p != NULL && p->value != x)
    {
        w = p;
        p = p->next;
    }
    if (p != NULL)
    {
        if (p == head)
            head = p->next;
        else
            w->next = p->next;
    }
    return head;
}

这样的函数如下：（虽然增加了复杂度，但是并不要求链表有序）

Node* Difference(Node* head1, Node* head2)
{
    Node* copy = copyList(head1);
    Node* q = head2;
    while (q!= NULL)
    {
        int x = q->value;
        copy = delete(copy, x);
        q = q->next;
    }
    return copy;
}

求集合的交集，最简单的，还是直接用双指针依次历遍，如果遇到了相同的元素，就放入新链表（依旧充分利用了链表有序）：

Node* intersectionSets(Node* S1, Node* S2) {
    Node* result = NULL;
    Node* tail = NULL;

    Node* currentS1 = S1;
    Node* currentS2 = S2;

    while (currentS1 != NULL && currentS2 != NULL) {
        if (currentS1->value < currentS2->value) {
            currentS1 = currentS1->next;
        }
        else if (currentS1->value > currentS2->value) {
            currentS2 = currentS2->next;
        }
        else {
            //相等时添加节点到结果中
            Node* newNode = createNode(currentS1->value);
            if (result == NULL) {
                result = newNode;
                tail = newNode;
            }
            else {
                tail->next = newNode;
                tail = newNode;
            }
            currentS1 = currentS1->next;
            currentS2 = currentS2->next;
        }
    }

    return result;
}

当然，也还有另一种方法，利用删除表元的函数，对于S1（复制出来的）中每一个元素，查看S2中是否有相等的元素，如果没有就将它删去，这样依旧是可以实现无序集合的处理：

Node* Intersection(Node* head1, Node* head2)
{
    Node* copy = copyList(head1);
    Node* p = copy;
    while (p != NULL)
    {
        int x = p->value, flag = 0;
        Node* q = head2;
        while (q)
        {
            if (q->value == x)
            {
                flag = 1;
                break;
            }
            q = q->next;
        }
        if (flag == 0)
        {
            copy = delete(copy, x);
        }
        p = p->next;
    }
    return copy;
}

以下是完整的程序和样例：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
    int value;
    struct Node* next;
} Node;
// 创建新节点
Node* createNode(int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    newNode->value = value;
    newNode->next = NULL;
    return newNode;
}
// 创建原始链表
Node* createOriginalList() {
    Node* head = NULL;
    Node* tail = NULL;
    int n;
    printf("Enter the number of nodes in the linked list:");
    scanf("%d", &n);
    printf("Enter the values of the linked list nodes:\n");
    for (int i = 0; i < n; i++) {
        int value;
        printf("Value of Node %d：", i + 1);
        scanf("%d", &value);

        Node* newNode = createNode(value);
        if (NULL == head) {
            head = newNode;
            tail = newNode;
        }
        else {
            tail->next = newNode;
            tail = newNode;
        }
    }

    return head;
}
// 打印链表
void printList(Node* head) {
    if (head == NULL) {
        printf("链表为空。\n");
        return;
    }
    Node* current = head;

    while (current != NULL) {
        printf("%d ", current->value);
        current = current->next;
    }
    printf("\n");
}
// 释放链表内存
void freeList(Node* head) {
    Node* current = head;
    Node* next;

    while (current != NULL) {
        next = current->next;
        free(current);
        current = next;
    }
}
// 求集合的并集
Node* unionSets(Node* S1, Node* S2) {
    Node* result = NULL;//result为新链表头指针
    Node* tail = NULL;//新链表尾指针

    Node* currentS1 = S1;
    Node* currentS2 = S2;

    //双指针分别遍历S1和S2，直到其中一个被遍历完，按从小到大的顺序添加节点到结果中
    while (currentS1 != NULL && currentS2 != NULL) {
        if (currentS1->value < currentS2->value) {
            Node* newNode = createNode(currentS1->value);
            if (result == NULL) {
                result = newNode;
                tail = newNode;
            }
            else {
                tail->next = newNode;
                tail = newNode;
            }
            currentS1 = currentS1->next;
        }
        else if (currentS1->value > currentS2->value) {
            Node* newNode = createNode(currentS2->value);
            if (result == NULL) {
                result = newNode;
                tail = newNode;
            }
            else {
                tail->next = newNode;
                tail = newNode;
            }
            currentS2 = currentS2->next;
        }
        else {//比较的两者相同，插入其中的一个
            Node* newNode = createNode(currentS1->value);
            if (result == NULL) {
                result = newNode;
                tail = newNode;
            }
            else {
                tail->next = newNode;
                tail = newNode;
            }
            //相等时双指针均后移
            currentS1 = currentS1->next;
            currentS2 = currentS2->next;
        }
    }
    //对于s1，s2中剩下的表元（如果有）
    while (currentS1 != NULL) {
        Node* newNode = createNode(currentS1->value);
        if (result == NULL) {
            result = newNode;
            tail = newNode;
        }
        else {
            tail->next = newNode;
            tail = newNode;
        }
        currentS1 = currentS1->next;
    }

    while (currentS2 != NULL) {
        Node* newNode = createNode(currentS2->value);
        if (result == NULL) {
            result = newNode;
            tail = newNode;
        }
        else {
            tail->next = newNode;
            tail = newNode;
        }
        currentS2 = currentS2->next;
    }

    return result;
}
// 求集合的差集
Node* differenceSets(Node* S1, Node* S2) {
    Node* result = NULL;
    Node* tail = NULL;
    Node* currentS1 = S1;
    Node* currentS2 = S2;
    while (currentS1 != NULL && currentS2 != NULL) {
        //对于S2中的每一个节点值，添加S1中比其小的所有节点到结果中
        if (currentS1->value < currentS2->value) {
            Node* newNode = createNode(currentS1->value);
            if (result == NULL) {
                result = newNode;
                tail = newNode;
            }
            else {
                tail->next = newNode;
                tail = newNode;
            }
            currentS1 = currentS1->next;
        }
        else if (currentS1->value > currentS2->value) {
            currentS2 = currentS2->next;
        }
        else {
            currentS1 = currentS1->next;
            currentS2 = currentS2->next;
        }
    }
    while (currentS1 != NULL) {
        //添加S1剩余节点到结果中
        Node* newNode = createNode(currentS1->value);
        if (result == NULL) {
            result = newNode;
            tail = newNode;
        }
        else {
            tail->next = newNode;
            tail = newNode;
        }
        currentS1 = currentS1->next;
    }
    return result;
}

// 求集合的交集
Node* intersectionSets(Node* S1, Node* S2) {
    Node* result = NULL;
    Node* tail = NULL;

    Node* currentS1 = S1;
    Node* currentS2 = S2;

    while (currentS1 != NULL && currentS2 != NULL) {
        if (currentS1->value < currentS2->value) {
            currentS1 = currentS1->next;
        }
        else if (currentS1->value > currentS2->value) {
            currentS2 = currentS2->next;
        }
        else {
            //相等时添加节点到结果中
            Node* newNode = createNode(currentS1->value);
            if (result == NULL) {
                result = newNode;
                tail = newNode;
            }
            else {
                tail->next = newNode;
                tail = newNode;
            }
            currentS1 = currentS1->next;
            currentS2 = currentS2->next;
        }
    }
    return result;
}

int main() {
    printf("Creating the first set:\n");
    Node* S1 = createOriginalList();

    printf("Creating the second set:\n");
    Node* S2 = createOriginalList();

    printf("Set 1: ");
    printList(S1);

    printf("Set 2: ");
    printList(S2);

    printf("Union of Set 1 and Set 2: ");
    Node* unionResult = unionSets(S1, S2);
    printList(unionResult);

    printf("Difference of Set 1 and Set 2: ");
    Node* differenceResult = differenceSets(S1, S2);
    printList(differenceResult);

    printf("Intersection of Set 1 and Set 2: ");
    Node* intersectionResult = intersectionSets(S1, S2);
    printList(intersectionResult);
    
    freeList(intersectionResult);
    freeList(differenceResult);
    freeList(unionResult);
    freeList(S2);
    freeList(S1);
    return 0;
}

对于这一类问题，还有每个链表都带辅助表元的情况，我们也就可以用一个值为0（或其他没有意义的数）的头指针指向每一个链表。这样，操作时的插入新表元不需要考虑是否是头指针了，大体的程序是一样的。

zhuoer_GG
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Redis有序集合类型的常用命令小结
09-10
有序集合中的每个元素都有一个唯一的成员（member）和一个与之关联的分数（score），并按照分数的大小进行排序。分数决定了成员在集合中的位置，可以是整数或浮点数。这种数据结构在需要对数据进行排序时非常有用，...
含交、并和差的集合类型运算的C实现
09-21
本主题将深入探讨如何使用C语言实现这些运算，特别是针对有序链表表示的正整数集合。有序链表是一种高效的数据结构，适用于这类运算，因为它的元素是有序的，可以简化查找和比较的过程。 首先，我们需要定义一个...
集合交差并三种操作的C实现
08-10
交集的实现可以通过遍历两个集合，将存在于两个集合中的元素添加到结果集中。差集的计算则需要将第一个集合中的元素与第二个集合进行比较，排除掉在第二个集合中存在的元素。并集是将两个集合的所有元素合并，但要...
java集合分类总结.doc
12-21
Arrays和Collections是Java集合中的两个工具类。Arrays类包含用来操作数组的各种方法，如排序和搜索等。Collections类主要提供了在collection上进行操作的方法，如排序、查找等。 学习Java集合需要掌握以下几个方面...
计算器 实现复数、有理数、矩阵和集合的特殊计算 编译程序代码
05-30
集合的基本操作包括求交集（找到两个集合共有的元素）、并集（组合两个集合的所有元素）和子集判断（检查一个集合是否包含在另一个集合中）。这些操作在算法中广泛使用，需要高效实现。 5. **编译程序代码**： 这...
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
最新发布
铁匠匠匠的博客
07-18 520
可以参考以下视频。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 92
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构初阶(C语言）-复杂度的介绍
xiuwoaiailixiya的博客
07-14 1038
在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运行时间。时 间复杂度是衡量程序的时间效率，那么为什么不去计算程序的运行时间呢？1. 因为程序运行时间和编译环境和运行机器的配置都有关系，比如同⼀个算法程序，用⼀个老编译 器进行编译和新编译器编译，在同样机器下运行时间不同。2. 同⼀个算法程序，用⼀个老低配置机器和新高配置机器，运行时间也不同。3. 并且时间只能程序写好后测试，不能写程序前通过理论思想计算评估。
【数据结构】详解堆
老师我想进步
07-16 655
升序：建大堆降序：建小堆（1）升序：建大堆【思考】排升序，建小堆可以吗？-- 可以（但不推荐）。首先对 n 个数建小堆，选出最小的数，接着对剩下的 n-1 个数建小堆，选出第二小的数，不断重复上述过程。【时间复杂度】建 n 个数的堆时间复杂度是 O(N)，所以上述操作时间复杂度为 O(N²)，效率太低，关系变得杂乱，尤其是当数据量大的时候，效率就更低。同时堆的价值也没有被体现出来，这样不如用直接排序。排升序，因为数字依次递增，需要找到最大的数字，得建大堆。首先对 n 个数建大堆。
数据结构之细说链表
m0_73634434的博客
07-17 596
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
数据结构(4.4)——求next数组
m0_65240792的博客
07-14 363
next[1]都无脑写0next[2]都无脑写1其他next:在不匹配的位置前边，划一条分界线，模式串一步一步往后退，直到分界线之前"能对上"，或模式串能完全跨过分界线为止，此时j指向哪儿，next数组值就是多少ababaa的next数组//求next[1]??????->??????/i=1->i=2ababaa-> ababaa //j=0,第一个字符匹配失败，只能匹配下一个子串，++i，++jnext[1]=0;//求next[2]a?????->a??????//i=2。
常见排序算法
weixin_56898048的博客
07-17 546
介绍了常见的排序算法，冒泡排序，插入排序，希尔排序，选择排序，堆排序，快速排序，归并排序和计数排序的代码实现以及这些排序算法的时间复杂度和空间复杂度
数据结构 day2
没有百宝袋的哆啦A梦的博客
07-17 810
由相同数据类型或不同数据类型构成的集合，但是，该集合中的成员共享同一块内存空间union 结构体名称成员类型1 成员变量1;成员类型2 成员变量2；。。。成员类型n 成员变量n;当程序员写程序时，可能会因为数据类型的问题，在定义变量时，导致该程序比较晦涩难懂，例如：unsigned long int ,struct Stu为了提高代码的简洁性，以及为了更加方便理解使得代码更加优雅，我们可以将这些类型重新起一个简洁好记的名字。引入了关键字 typedef。
排序思想-快排
m0_58257626的博客
07-17 133
快速排序核心思想就是每次在当前区间 [left, right] 中选择出一个元素 nums[p]，然后将区间内所有大于它的元素和所有小于它的元素都放到其两侧【具体放在哪一侧取决于是升序还是降序】，然后再递归去处理两侧区间。将大于切分值的元素都放到左侧，小于切分值得元素都放到右侧。因此我们可以使用双指针分别从两端往中间搜索，分别找到左侧小于切分值的元素和右侧大于切分值的元素，交换之，直到两个指针相遇。
创建空数据结构：列表、元组、字典和集合
2202_75569688的博客
07-17 98
在 Python 编程中，数据结构是存储和管理数据的基本单元。常用的数据结构包括列表、元组、字典和集合。在实际编程中，时常需要初始化这些数据结构为空。本文将详细介绍如何创建空列表、空元组、空字典和空集合。
02 数据结构 ——链表（静态/循环/双向/LINUX内核链表）
weixin_65029285的博客
07-17 320
Linux内核链表是一种通用的双向循环链表，面对通用的问题，Linux内核链表的节点干脆不存储任何数据域，只有指针域，节点只负责串联起每个节点，不负责存储数据。目的：根据结构体中某个成员的地址，能够计算出所在结构体的首地址，从而用户在设计Linux内核链表的节点时，不需要一定放在在数据的首位成员，增加可用性。在双向链表的基础上，让最后一个节点的next指向头节点，让头节点的prev指向最后一个节点，构成了双向循环链表。静态链表的节点存储在一段连续内存中，通过节点中称为游标的一个正整数来访问后继节点。
5Python的Pandas：数据结构
XiaoCai
07-13 646
Pandas是基于强大的NumPy库开发的，它继承了NumPy中的一些数据结构，也继承了NumPy的高效计算特性。
【Java--数据结构】栈的应用
2301_80898480的博客
07-14 729
如有错误，欢迎指出~
（9）Python 数据结构：构建高效算法与金融应用的基石
架构筑梦的Cherry Yang的博客
07-14 771
当我们谈论数据结构时，我们实际上是在探讨一种组织、存储和管理数据的系统方法。在编程中，数据结构的选择对程序的性能、可读性和可维护性都有着深远的影响。Python，作为一种功能强大且易于学习的编程语言，提供了丰富的数据结构供我们使用。
c语言写利用有序链表表示下整数任命，输入集合A和B,实现信息的交、并和差运算。
06-08
有了这些基本操作函数，我们就可以实现集合的交、并和差运算了。具体来说，对于集合A和B，我们可以分别创建两个有序链表，然后进行如下操作： - 并集：遍历A和B两个有序链表，将它们的元素插入到一个新的有序链表中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值