精华内容
下载资源
问答
  • 个人资料整理 仅限学习使用 课程设计报告 课程设计题目实现两个链表合并 学生姓名 黎微微 专 业 计算机信息管理 班 级 1141301 指导教师 吴志强 2018年 01月 08 日 个人资料整理 仅限学习使用 一 课程设计目的 ...
  • 题目 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则.../*16-合并两个链表*/ #include<iostream> #include<queue> using namespace std; struct ListNod...

    题目

    输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。

    考察点

    • 链表

    解题思路

    • 递归实现,比较每个节点大小,将较小的放入新链表
    • 非递归,原理同上

    完整代码

    /*16-合并两个链表*/
    #include<iostream>
    #include<queue>
    using namespace std;
    struct ListNode {
    	int val;
    	struct ListNode *next;
    	ListNode(int x) :
    			val(x), next(NULL) {
    	}
    };
    class Solution {
    public:
     
    	//递归实现 ,合并与排序一起进行
    	ListNode* Merge2(ListNode* pHead1, ListNode* pHead2)
    	{
    		ListNode* ListMerge;
    		if (pHead1 == NULL)
    			return pHead2;//???ListMerge = pHead2;会产生堆栈溢出
    		if (pHead2 == NULL)
    			return pHead1;//????ListMerge = pHead1;
    		//针对每一个节点进行比较
    		if (pHead1->val > pHead2->val)
    		{
    			ListMerge = pHead2;///将较小的赋值给要输出的链表
    			ListMerge->next = Merge2(pHead1, pHead2->next);//继续对pHead1.pHead2的下一位进行递归,赋值给要输出的链表的下一位
    		}
    		else
    		{
    			ListMerge = pHead1;
    			ListMerge->next = Merge2(pHead1->next, pHead2);
    		}
    		return ListMerge;
    	}
    };
    int main()
    {
    	ListNode *p1 = new ListNode(1); ListNode *p2 = new ListNode(3); ListNode *p3 = new ListNode(5);
    	ListNode *p4 = new ListNode(2); ListNode *p5 = new ListNode(4); ListNode *p6 = new ListNode(6);
    	p1->next = p2; p2->next = p3;  p4->next = p5; p5->next = p6;
    	Solution s;
    	ListNode* result;
    	result = s.Merge(p1, p4);
    	//result = s.Merge2(p1, p4);
    	//打印链表
    	queue<ListNode*> res;
    	ListNode* Node = result;
    	while (Node != NULL)//压入队列
    	{
    		res.push(Node);
    		Node = Node->next;
    	}
    	while (!res.empty())//出队列
    	{
    		Node = res.front();
    		cout << Node->val << ' ';
    		res.pop();
    
    	}
    	return 0;
    }
    

    编程问题

    • 链表的打印:顺序打印可用队列实现;逆序可用栈实现;
    • 返回值问题: 原因目前未知。
    if (pHead1 == NULL)
    			return pHead2;//???ListMerge = pHead2;会产生堆栈溢出
    		if (pHead2 == NULL)
    			return pHead1;//????ListMerge = pHead1;
    
    展开全文
  • 数据结构课程方案实现两个链表合并.pdf
  • 给定两个链表AB,根据AB链表元素数目的不同,使用交叉排列得到链表C,之后对链表C进行升序排列得到链表D
  • 实现两个链表合并

    2014-07-06 16:25:51
    (1)建立两个链表A和B 链表元素个数分别为m和n个 (2)假设元素分别为 x1 x2 …xm 和 y1 y2 …yn 把它们合并成一个线性表C 使得: 当m> n时 C x1 y1 x2 y2 …xn yn … xm 当n>m时 C y1 x1 y2 x2 …ym xm ...
  • C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现
  • 主要介绍了JS实现合并两个有序链表算法,结合实例形式分析了JavaScript链表的定义、节点插入、删除、查找等相关算法实现技巧,需要的朋友可以参考下
  • Mergel(A,B) 合并成 C对 Mergel(A,B) 合并成 C 对 C 排序生成 D Creat A 链表 Creat B 链表 一 需求分析 题目 实现两个链表合并 问题描述 1. 建立两个链表 A 和 B链表元素个数分别为 m 和 n 个 2. 假设元素分别为...
  • 如下所示: #include #include #include using namespace std; struct Node { int data; Node *next; }; //初始化 Node *init() { Node *head=new Node; head->next=NULL;... cur->next=head->n
  • 网页 资讯 视频 图片 知道 文库 贴吧 采购 地图 | 百度首页 登录 VIP新客立减2元 意见反馈 下载客户端 12/30/2019 数据结构课程设计实现两个链表合并 - 百度文库 首页 分类 精品内容 申请认证 机构合作 频道专区 ...
  • Java实现两个有序的链表合并

    千次阅读 2018-10-27 15:11:03
    Java实现两个有序的链表合并实现两个有序链表 代码如下: SingleLinkedList sll1 = new SingleLinkedList(); for (int i = 0; i &lt; 10; i += 2) { SingleNode node = new SingleNode(i, null); ...

    Java实现两个有序的链表合并

    先实现两个有序链表

    代码如下:

            SingleLinkedList sll1 = new SingleLinkedList();
            for (int i = 0; i < 10; i += 2) {
                SingleNode node = new SingleNode(i, null);
                sll1.add(node);
            }
            System.out.println("单向链表1:" + sll1.toString());
    
            SingleLinkedList sll2 = new SingleLinkedList();
            for (int i = 1; i < 12; i += 2) {
                SingleNode node = new SingleNode(i, null);
                sll2.add(node);
            }
            System.out.println("单向链表2:" + sll2.toString());
    

    输出:如下所示,跟预期一致。

        单向链表1:SingleLinkedList:[0, 2, 4, 6, 8]
        单向链表2:SingleLinkedList:[1, 3, 5, 7, 9, 11]
    

    嵌套调用,完成两个有序链表的合并。

        public SingleNode mergeTwoLists(SingleNode l1, SingleNode l2) {
            if (l1 == null) {
                return l2;
            }
            if (l2 == null) {
                return l1;
            }
            SingleNode mergedNode;
            if (l1.getItem() < l2.getItem()) {
                mergedNode = l1;
                mergedNode.next = mergeTwoLists(l1.next, l2);
            } else {
                mergedNode = l2;
                mergedNode.next = mergeTwoLists(l2.next, l1);
            }
            return mergedNode;
        }
    

    下面进行测试,代码如下:

            SingleNode mergedNode = mergeTwoLists(sll1.getFirst(), sll2.getFirst());
            sll1.logFromHead("mergedNode", mergedNode);
    

    输出结果如下:结果跟预期的一致。

        单向链表1:SingleLinkedList:[0, 2, 4, 6, 8]
        单向链表2:SingleLinkedList:[1, 3, 5, 7, 9, 11]
        mergedNode:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]
    

    完整代码请查看

    项目中搜索SingleLinkedList即可。
    github传送门 https://github.com/tinyvampirepudge/DataStructureDemo

    gitee传送门 https://gitee.com/tinytongtong/DataStructureDemo

    参考:
    1、merge-two-sorted-lists

    2、使用Java实现单向链表,并完成链表反转。

    3、Java实现有环的单向链表,并判断单向链表是否有环

    展开全文
  • 主要为大家详细介绍了python实现合并两个排序的链表,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了Python实现合并两个有序链表的方法,涉及Python操作链表节点的遍历、判断、添加等相关操作技巧,需要的朋友可以参考下
  • c代码-将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
  • 两个有序链表的去重合并
  • 蠶需链表的合并数据结构 PAGE PAGE # 一课程设计题目: 实现两个链表合并 二 基本功能要求 建立两个链表A和B,链表元素个数分别为m和n个 假设元素分别为(xl, x2, xm,和(yl, y2?yn)把它们合并成一个线性表C, 使得 当 ...
  • 3、将两个从小到大排列的链表合并为一个新链表(仍然有序排列),输出合并前的两个链表,输出合并后的链表,检查合并是否成功。
  • 实现两个链表合并(数据结构课程设计c语言版)
  • 主要为大家详细介绍了C++实现合并两个排序的链表,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 1、学习数据结构 用代码实现入门程序。 2、[数据结构(C语言版)].严蔚敏_吴伟民 版代码实现,可直接运行
  • 一课程设计题目 实现两个链表合并 二基本功能要求 1. 建立两个链表 A 和 B链表元素个数分别为m 和 n 个 2. 假设元素分别为(x1,x2,xm)和(y1,y2, yn)把它们合并成一个线性表 C使 得 当m>=n 时C=x1,y1,x2,y2,xn,yn,xm...
  • 该算法为将两个递增的链表合并为一个递减链表,采用头插法和尾插法两种不同的方法实现
  • 两个有序的链表合并为一个有序链表,链表的大小是可变的
  • 本篇文章是对将两个链表非降序合并为一个链表并依然有序的实现方法进行了详细的分析介绍,需要的朋友参考下
  • 两个有序链表合并

    2019-03-14 11:16:17
    两个有序的链表合并成一个链表,合并后的链表仍然是有序的,依次输出合并后的链表的元素值,并求出第奇数位置元素之和
  • 主要为大家详细介绍了java编程题之合并两个排序的链表,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • //头指针就可以直接看做这个链表的名字 LinkList La; LinkList Lb; LinkList Lc; int n; int na; int nb; int i; int e; printf("请输入La链表的长度:\n"); scanf("%d",&na); CreatList(&La,na); printf("请输入Lb...

    #include <stdio.h>
    #include <malloc.h>
    #include <stdlib.h>
    typedef struct LNode{
    int data;
    struct LNode * next;
    }LNode ,* LinkList ;
    void CreatList(LinkList * L,int n);
    void ListTraverse(LinkList );
    bool GetElem(LinkList L,int *i,int *e);

    bool ListInsert(LinkList L,int i,int e) ;
    bool ListDelete(LinkList L,int i ,int e);
    void MergeList(LinkList La,LinkList Lb,LinkList Lc);
    int main(){
    LinkList L;//头指针就可以直接看做这个链表的名字
    LinkList La;
    LinkList Lb;
    LinkList Lc;

    int n;
    int na;
    int nb;
    int i;
    int e;
    printf("请输入La链表的长度:\n");
    scanf("%d",&na);
    CreatList(&La,na);
    printf("请输入Lb链表的长度:\n");
    scanf("%d",&nb);
    CreatList(&Lb,nb);
    CreatList(&Lc,0);
    ListTraverse(La);
    ListTraverse(Lb);
    MergeList(La,Lb,Lc);//把La和Lb归并为Lc 
    

    // ListTraverse(La);
    // ListTraverse(Lb);
    ListTraverse(Lc);

    //ListInsert(L,i,e) ;//将链表某个位置插入某个元素 
    //ListDelete(L,i,e);//将链表中某个位置的元素删除,并且把删除的元素返回 
    ListTraverse(L);
    

    // if(GetElem(L,&i,&e)&&i>0)
    // else
    //printf(“第%d上的元素是%d\n”,i,e);

    //GetElem(L,&i,&e);//获取链表上某位置 应的元素 
    return 0;
    

    }

    void CreatList(LinkList * L,int n){ //创建链表的长度,并对其赋值
    *L=(LinkList)malloc(sizeof(LNode));
    (*L)->next=NULL;
    LinkList p;
    p=(*L);
    int i;
    if(n<0)
    {
    printf(“输入的长度有误!\n”);
    exit(0) ;
    }
    if(n>0)
    printf(“请依次输入数组中的元素\n”);
    for(i=n;i>0;i–){
    p->next =(LinkList)malloc(sizeof(LNode));//p->next==(*L)->nest 把首节点的地址存放在头结点里面的指针域里面
    scanf("%d",&(p->next->data));
    p->next->next=NULL;
    p=p->next;//是使p指向首节点
    }

    }
    void ListTraverse(LinkList L){
    int i=1;
    if(L->next ==NULL){
    printf(“链表为空!\n”);
    return;
    }

    printf("\n数组中的元素如下:\n");
    while(L!=NULL){
    	if(i!=1)
    	printf("%d	",L->data);
    	L=L->next;
    	i++;
    }
    

    }
    bool GetElem(LinkList L,int *i,int *e){
    if(L->next ==NULL){
    printf(“链表为空!”);
    return false;
    }
    printf("\n请输入你想看的位置!\n");
    scanf("%d",i);//i<1 不合法返回false
    if(*i<1){

    printf(“输入的位置有误!”);
    return false;
    }
    int j=1;
    LinkList p;
    p=L->next;
    while(p!=NULL&&j<*i){
    p=p->next;
    j++;
    }

    if(p==NULL)  {
    

    printf(“输入的位置超出链表长度!”);
    return false;
    }
    else *e=p->data;

    return true;
    

    }
    bool ListInsert(LinkList L,int i,int e) {
    LinkList p=L;//L=L->next;
    //1、插入的链表为空
    //2.链表不为空
    if(p->next NULL){ //链表为空
    printf(“请输入插入的位置!\n”);
    scanf("%d",&i);
    if(i
    1){
    printf(“请输入插入的元素!\n”);
    scanf("%d",&e);
    LinkList s=(LinkList)malloc(sizeof(LNode));
    if(s==NULL)
    exit(-1);
    p->next =s;
    s->data=e;
    s->next =NULL;
    return true;
    }
    else{
    printf(“插入位置错误!\n”);
    return false;

    }
    }
    

    int j=0;
    printf(“请输入插入的元素的位置!\n”);
    scanf("%d",&i);
    if(i>0){
    while(p&&j<i-1) //j表示的是p指向的链表的位置
    {
    p=p->next ;
    j++;

    	}
    if(p==NULL)	
    {
    	printf("插入位置大于链表长度!\n"); 
    	return false;
    	
    }
    
    if(j==i-1){
    	printf("请输入插入的元素\n");
    	scanf("%d",&e); 
    	LinkList s=(LinkList)malloc(sizeof(LNode));
    	if(s==NULL)
    	exit(-1);
    	s->data =e;
    	s->next =p->next;
    	p->next =s;	
    	return true;	
    	
    }	
    }
    else{
    printf("插入位置错误!\n");
    return false; 	
    }
    

    }
    bool ListDelete(LinkList L,int i ,int e){
    //1.链表为空 返回false
    //2.链表不为空 插入的位置有误(i<1或者删除的位置大于链表的最大长度) 插入位置正确
    //3.删除的元素是否为最后一个
    LinkList p=L;
    if(p->next NULL){//链表为空
    printf(“链表为空 !\n”);
    return false;
    }
    printf("\n请输入删除的位置!\n");
    scanf("%i",&i);
    if(i<1){
    printf(“删除位置非法 !\n”);
    return false;
    }
    int j=0;//让j指向的是p指向的节点的位置
    while(p->next &&j<i-1){
    p=p->next ;
    j++;
    }
    if(p->next
    NULL ){
    printf(“删除位置超出链表的长度 !\n”);
    return false;
    }
    else{

    	if(p->next->next==NULL){
    	e=p->next->data;
    	free(p->next);
    	p->next =NULL;
    	printf("被删除的元素是%d\n",e);	
    	return true;
    	}	
    	else{		
    	e=p->next->data;
    	printf("被删除的元素是%d\n",e);
    	LinkList q=p;
    	q=p->next;
    	p->next=p->next->next;
    	free(q);
    	return true;	
    	}	
    }	
    

    }

    void MergeList(LinkList La,LinkList Lb,LinkList Lc){
    LinkList pa=La->next ;
    LinkList pb=Lb->next;
    LinkList pc=Lc;
    while(pa &&pb ){
    if(pa->datadata ){
    pc->next =pa;
    pa=pa->next ;
    pc =pc->next ;
    }
    else{
    pc->next =pb;
    pb=pb->next ;
    pc =pc->next ;
    }
    }
    LinkList q=pa?pa:pb;
    while(q){

    		pc->next  =q;
    		q=q->next ;
    		pc =pc->next  ;
    	
    }
    	
    		
    }
    
    展开全文
  • 两个链表求交集In computer science, a linked list is a linear collection of data elements, whose order is not given by their physical placement in memory. Instead, each element points to the next. It ...

    两个链表求交集

    In computer science, a linked list is a linear collection of data elements, whose order is not given by their physical placement in memory. Instead, each element points to the next. It is a data structure consisting of a collection of nodes which together represent a sequence. In its most basic form, each node contains data and a reference (in other words, a link) to the next node in the sequence. This structure allows for efficient insertion or removal of elements from any position in the sequence during iteration. More complex variants add additional links, allowing more efficient insertion or removal of nodes at arbitrary positions.

    在计算机科学中,链表是数据元素的线性集合,其顺序不是由它们在内存中的物理位置给出的。 相反,每个元素都指向下一个。 它是一种数据结构,由节点的集合组成,这些节点一起代表一个序列。 以其最基本的形式,每个节点都包含数据和对序列中下一个节点的引用(换句话说,就是链接)。 这种结构允许在迭代过程中从序列中的任何位置有效插入或删除元素。 更复杂的变体会添加其他链接,从而可以更有效地在任意位置插入或删除节点。

    Union of two linked lists can be found by using merging the lists in a sorted manner.

    两个链接列表的联盟可以通过合并列表的排序方式找到。

    The intersection of the two lists can be found by only taking common elements while merging the two lists.

    通过合并两个列表时仅采用公共元素,可以找到两个列表的交集

    It has been assumed that the linked lists are sorted.

    假定已对链表进行排序

    Algorithm:

    算法:

    Union(L1,L2)

    联合(L1,L2)

        1) Declare node pointer output, output Tail as NULL
        2) Repeat steps 3 to 9 while L1!=NULL AND L2!=NULL
        3) Make a newNode and set its next = NULL
        4) If L1->data < L2->data then
            Set newNode->data = L1->data
            Set L1 = L1->next
        5) Else if L1->data > L2->data then
            Set newNode->data = L2->data
            L2 = L2->next
        6) Else
            i) Set Data = L1->data
            ii) Set newNode->data = Data
            iii) Repeat steps a) and b) 
            while L1!=NULL AND L2!=NULL AND L1->data == Data AND L2->data == Data
                a) Set L1 = L1->next
                b) Set L2 = L2->next
    
        7) If output == NULL then
            Set Output = outputTail = newNode
    
        8) Else
            a) Set outputTail->next = newNode
            b) Set outputTail = outputTail->next
         9) Repeat steps 10 to 14 while L1!=NULL
        10) Make a newNode
        11) Set outputTail->next = newNode
        12) Set outputTail = outputTail->next
        13) Set outputTail->data = L1->data
        14) Set L1 = L1->next
            Repeat steps 15 to 19 while L2!=NULL
        15) Make a newNode
        16) Set outputTail->next = newNode
        17) Set outputTail = outputTail->next
        18) Set outputTail->data = L2->data
        19) Set L2 = L2->next
            Return output
    
    

    Intersection(L1,L2)

    交叉路口(L1,L2)

        1.	If L1 or L2 is NULL then return NULL
        2.	Declare node pointers output, outputTail as null.
        3.	Repeat steps 4 to 6 while L1!=NULL AND L2!=NULL
        4.	If L1->data
       
        data then
            Set L1 = L1->next
        5.	Else If L2->data
        
         data then
            Set L2 = L2->next
        6.	Else
            a)	Declare and set data = L1->data
            b)	Make a newNode
            c)	Set newNode->data = data and newNode->next = NULL
            d)	If output == null then
                i.	Set output = outputTail = newNode
            e)	Else
                i.	Set outputTail->next = newNode
                ii.	Set outputTail = outputTail->next
            f)	Repeat steps i and ii 
            while L1!=NULL AND L2!=NULL AND L1->data == data AND L2->data == data
                i.	Set L1 = L1->next
                ii.	Set L2 = L2->next
    
        
       
    
    

    Code:

    码:

    #include <stdio.h>
    #include <stdlib.h>
    
    struct node{
    	struct node*next;
    	int data;
    };
    
    struct node * Union(struct node * L1, struct node * L2){
    	struct node * output = NULL;
    	struct node * outTail = NULL;
    	while(L1&&L2){
    		struct node * newNode = (struct node *) malloc(sizeof(struct node));
    		newNode->next = NULL;
    		if(L1->data<L2->data){
    			newNode->data = L1->data;
    			L1 = L1->next;
    		}
    		else if(L1->data>L2->data){
    			newNode->data = L2->data;
    			L2 = L2->next;
    		}
    		else{
    			int data = L1->data;
    			newNode->data = data;
    			while(L1 && L2 && L1->data == data && L2->data == data){
    				L1 = L1->next;
    				L2 = L2->next;
    			}
    		}
    		if(!output)
    			output = outTail = newNode;
    		else{
    			outTail->next = newNode;
    			outTail = outTail->next;
    		}
    	}
    	while(L1){
    		outTail->next = (struct node *) malloc(sizeof(struct node));
    		outTail = outTail->next;
    		outTail->data = L1->data;
    		L1 = L1->next;
    	}
    	while(L2){
    		outTail->next = (struct node *) malloc(sizeof(struct node));
    		outTail = outTail->next;
    		outTail->data = L2->data;
    		L2 = L2->next;
    	}
    	outTail->next = NULL;
    	return output;
    }
    
    struct node * intersection(struct node * L1, struct node* L2){
    	if(L1 == NULL || L2 == NULL)
    		return NULL;
    	struct node * output = NULL;
    	struct node * outTail = NULL;
    	while(L1&&L2){
    		if(L1->data<L2->data){
    			L1 = L1->next;
    		}
    		else if(L2->data<L1->data){
    			L2 = L2->next;
    		}
    		else{
    			int data = L1->data;
    			struct node * newNode = (struct node *) malloc(sizeof(struct node));
    			newNode->data = data;
    			newNode->next = NULL;
    			if(output == NULL){
    				outTail = output = newNode;
    			}
    			else{
    				outTail->next = newNode;
    				outTail = outTail->next;
    			}
    			while(L1 && L2 && L1->data == data && L2->data == data){
    				L1 = L1->next;
    				L2 = L2->next;
    			}
    		}
    	}
    	return output;
    }
    
    struct node * createList(int listNum){
    	struct node * list = NULL;
    	struct node * list_tail = NULL;
    	printf("Enter elements of List %d in increasing order\n",listNum);
    	char ch = 'y';
    	do{
    		int data;
    		printf("Enter element : ");
    		scanf("%d",&data);
    		struct node * newNode = (struct node *) malloc(sizeof(struct node));
    		newNode->data = data;
    		newNode->next = NULL;
    		if(list == NULL){
    			list = list_tail = newNode;
    		}
    		else{
    			list_tail->next = newNode;
    			list_tail = list_tail->next;
    		}
    		printf("Would you like to insert another element [Y/N] : ");
    		scanf(" %c",&ch);
    	}while(ch == 'y' || ch == 'Y');
    	
    	return list;
    }
    
    void print(struct node * list){
    	if(list == NULL){
    		printf("Empty List\n");
    		return;
    	}
    	while(list!=NULL){
    		printf("%d ",list->data);
    		list = list->next;
    	}
    	printf("\n");
    }
    
    int main() {
    	struct node * L1 = NULL;
    	struct node * L2 = NULL;
    	struct node * L3 = NULL;
    	struct node * L4 = NULL;
    	L1 = createList(1);
    	L2 = createList(2);
    	printf("List 1 : ");
    	print(L1);
    	printf("List 2 : ");
    	print(L2);
    	printf("Union : ");
    	L3 = Union(L1, L2);
    	print(L3);
    	printf("Intersection : ");
    	L4 = intersection(L1, L2);
    	print(L4);
    	return 0;
    }
    
    

    Output

    输出量

    Enter elements of List 1 in increasing order 
    Enter element : 1
    Would you like to insert another element [Y/N] : Y 
    Enter element : 4
    Would you like to insert another element [Y/N] : Y 
    Enter element : 9
    Would you like to insert another element [Y/N] : Y 
    Enter element : 27 
    Would you like to insert another element [Y/N] : N 
    Enter elements of List 2 in increasing order 
    Enter element : 4
    Would you like to insert another element [Y/N] : Y 
    Enter element : 9
    Would you like to insert another element [Y/N] : Y 
    Enter element : 18 
    Would you like to insert another element [Y/N] : Y 
    Enter element : 22 
    Would you like to insert another element [Y/N] : Y 
    Enter element : 30 
    Would you like to insert another element [Y/N] : N 
    List 1 : 1 4 9 27
    List 2 : 4 9 18 22 30
    Union : 1 4 9 18 22 27 30
    Intersection : 4 9 
    
    
    

    翻译自: https://www.includehelp.com/data-structure-tutorial/implement-union-and-intersection-of-two-sorted-linked-lists.aspx

    两个链表求交集

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 89,929
精华内容 35,971
关键字:

实现两个链表的合并