有两个循环链表，链头指针分别为L1和L2，要求写出算法将L2链表链到L1链表之后，且连接后仍保持循环_

shangan680

2024年12月22日 21:59

Void merge(LNode *L1,LNode *L2){

LNode *rear1 = l1;

LNode *rear2 =l2;

while(rear1->next!=L1) rear1->next = r1;

while(rear2->next!=L2) rear->next = r2;

rear1 -> next = rear2;

rear2 ->next = rear1;

}

lxy2001

2024年12月10日 22:16

void merge(Lnode *L1, Lnode *L2)

{Lnode *p = L1, *q = L2 ;

while(p->next!=L1)

p=p->next;

while(q->next!=L2)

q=q->next;

q->next=L1; p->next =L2;

}

muquew

2024年11月11日 21:42

void connextLink(LNode *L1, LNode *L2){
    LNode *rear1 = L1;
    LNode *rear2 = L2;

    //找到L1和L2的表尾
    while(rear1->next != L1) rear1 = rear1->next;
    while(rear2->next != L2) rear2 = rear2->next;

    rear1->next = L2;
    rear2->next = L1;
}

wwj0102

2024年11月10日 16:20

void connextLink(LNode *L1, LNode *L2){

LNode *rear1 = L1;

LNode *rear2 = L2;

//找到L1和L2的表尾

while(rear1->next != L1) rear1 = rear1->next;

while(rear2->next != L2) rear2 = rear2->next;

rear1->next = L2;

rear2->next = L1;

}

韩鹏

2024年10月18日 21:34

void link(btnode*l1,btnode*l2){

btnode *p1,*p2;

p1=l1;

p2=l2;

while(p1->next!=p1){

p1=p1->next;

}

while(p2->next!=p2){

p2=p2->next;

}

p1->next=l2;

p2->next=l1;

}

siyxo

2024年10月17日 09:30

void Contact(LinkList &L1, LinkList &L2){

LNode *p = L1;

while(p->next!=L1){

p = p->next;

}

p->next = L2;

p = L2;

while(p->next!=L2){

p = p->next;

}

p->next = L1;

}

wangcai

2024年10月16日 21:04

void Merge(LinkList *L1,LinkList *L2){

LinkList *rear1 = L1;

LinkList *rear2 = L2;

while(rear1 -> next != L1){

rear1 = rear1 -> next;

}

while(rear2 -> next != L2){

rear2 = rear2 -> next;

}

rear1 -> next = L2;

rear2 -> next = L1;

return L1;

}

mhhhx

2024年10月11日 15:09

void connect(LNode* L1, LNode* L2){
    if(!L1 || !L2) return;
    LNode* p = L1, *q = L2;

    while(p->next != L1){
        p = p->next;
    }
    
    while(q->next != L2){
        q = q->next;
    }

    p->next = L2;
    q->next = L1;

    return;
}

我与代码的故事

2024年9月29日 15:47

void connect(Lnode *L1, Lnode *L2)
{
	if(!L1 || !L2) return ;
	Lnode *p, *q;
	p = L1 -> next; 
	q = L2 -> next;
	//找到L1,L2尾结点 
	while(p)
	{
		if(p -> next == L1) break;
		p = p -> next; 
	}
	while(q)
	{
		if(q -> next == L2) break;
		q = q -> next; 
	}
	//合并 
	p -> next = L2;
	q -> next = L1;
}

heshuqi

2024年9月22日 10:50

void func(LNode *L1,LNode *L2){

LNode *p=L1->next;

LNode *q=L2->next;

while(p!=L1){

p=p->next;

}

while(q!=L2){

q=q->next;

}

p->next=L2;

q->next=L1;

}

lsssssj

2024年9月19日 20:33

首尾相连

世界和平

2024年9月18日 10:45

void merge(Lnode *L1, Lnode *L2)

{Lnode *p = L1, *q = L2 ;

while(p->next!=L1)

p=p->next;

while(q->next!=L2)

q=q->next;

q->next=L1; p->next =L2;

}

Conan_G

2024年9月12日 14:52

头尾相连

//先各自循环各表的尾结点再连接

void merge(Lnode *L1, Lnode *L2)

{Lnode *p = L1, *q = L2 ;

while(p->next!=L1)

p=p->next;

while(q->next!=L2)

q=q->next;

q->next=L1; p->next =L2;

}

kenshin_ying

2024年9月1日 11:16

找到L1的尾结点后续连接L2，再找到L2的尾结点后续连接L1

嘤狐

2024年8月29日 13:13

if(L1==NULL||L2==NULL)return;

node *p=L1;

while(p->next!=L1)p=p->next;

p->next=L2;

node *q=L2;

while(q->next!=L2)q=q->next;

q->next=L1;

现在只想上岸

2024年8月27日 11:29

ff

2893385654

2024年8月23日 17:17

#include<stdio.h>

typedef struct node {

int data;

struct node *next;

} person;

//初始化循环链表

person *initlink(int a[],int size) {

person *head=(person*)malloc(sizeof(person));

head->data=a[0];

head->next=NULL;

person *cyclic=head;

for(int i=1; i<size; i++) {

person *temp=(person*)malloc(sizeof(person));

temp->data=a[i];

temp->next=NULL;

cyclic->next=temp;

cyclic=cyclic->next;

}

cyclic->next=head;

return head;

}

//输出循环链表

void displaycyclic(person *p) {

person *temp=p;

do {

printf("%d",temp->data);

if(temp->next!=p) {

printf("->");

}

temp=temp->next;

} while(temp!=p);

putchar(10);

}

//连接

person *linklist(person *p1,person *p2) {

person *temp1=p1;

person *temp2=p2;

while(temp1->next!=p1) {

temp1=temp1->next;

}

while(temp2->next!=p2) {

temp2=temp2->next;

}

temp1->next=p2;

temp2->next=p1;

return p1;

}

int main()

{

int a[]= {1,2,3,4,5},b[]= {6,7,8,9,10};

int size1=sizeof(a)/sizeof(a[0]);

int size2=sizeof(b)/sizeof(b[0]);

person *L1=initlink(a,size1);

person *L2=initlink(b,size2);

displaycyclic(L1);

displaycyclic(L2);

person *head=linklist(L1,L2);

displaycyclic(head);

return 0;

}

缘小遇

2024年8月14日 14:35

typedef struct LNode{

int data;

LNode *next;

}LNode,*LinkList;

LinkList Link(LinkList &L1,LinkList &L2){

LNode *p,*q;

p=L1;

while(p->next!=L1)

p=p->next;

q=L2;

while(q->next!=L2)

q=q->next;

p->next=L2;

q->next=L1;

return L1;

}

Mapleman

2024年8月14日 09:24

void merge(Lnode *L1,Lnode *L2){
    Lnode *p=L1,*q=L2;
    while(p->next!=L1)
        p=p->next;
    while(q->next!=L2)
        q=q->next;
    p->next=L2;
    q->next=L1;
}

Fenda

2024年7月28日 11:42

void merge(Lnode *L1, Lnode *L2)

{Lnode *p = L1, *q = L2 ;

while(p->next!=L1)

p=p->next;

while(q->next!=L2)

q=q->next;

q->next=L1; p->next =L2;

}

与或非

2024年7月25日 19:10

void merge(LinkList L1, LinkList L2){

LinkNode *p = L1, *q = L2;

while(p->next != L1)

p = p->next;

while(q->next != L2)

q = q->next;

q->next = L1;

p->next = L2;

}

Austin00

2024年7月25日 13:01

struct RLnode{
    int data;
    RLnode *l,*r;

}
void join(RLnode * l1,RLnode * l2){
    RLnode * p = l1 , p1=l2;
    while(p->next!= l1){
       p = p->next;

    }

    while(p1->next!= l2){
       p1 = p1->next;

    }

    p->next = l2;
    p1 = next = l1;
}

Austin00

2024年7月25日 12:53

struct RLnode{
    int data;
    RLnode *l,*r;

}
void join(RLnode * l1,RLnode * l2){
    RLnode * l1_l = l1 ,
           * l1_r = l1->l,
           * l2_l = l2,
           * l2_r = l2->l ;

    l1_r->r = l2_l;
    l2_l->l = l1_r;
    l2_r->r = l1_l
    l1_l->l = l2_r;

}

blame

2024年7月25日 10:34

lNode p,q;

p =l1 q=l2

while(p->next != l1){

p = p->next

}

while(q->next != l2){

q = q->next

}

q->next=L1

p->next=L2

金头

2024年7月23日 22:28

void merge(Lnode *L1,Lnode *L2){

Lnode *p=L1;Lnode *q=L2;

while (p->next!=L1) p=p->next; //找到L1链尾

while (q->next!=L2) q=q->next; //找到L2链尾

p->next=L2;q->next=L1;

}

q992646222_

2024年7月23日 16:41

void merge(Lnode *L1,Lnode *L2){

Lnode *p=L1;Lnode *q=L2;

while (p->next!=L1) p=p->next; //找到L1链尾

while (q->next!=L2) q=q->next; //找到L2链尾

p->next=L2;q->next=L1;

}

你这

2024年7月23日 12:15

L2->pre = L1;

L1->pre = L2;

17679377259

2024年6月16日 10:54

List* l1 = L1;
while(l1->next != L1){
l1 = l1->next;
}
l1->next = L2;

List* l2 = L2;
while(l2->next != L2){
l2=l2->next;
}
l2->next = L1;

刷题小子

2024年6月13日 21:30

//注意是链头指针且是循环链表尾部必然指向头部

Lnode *p =L1,*q = L2;

while(p->next != L1) p = p->next; //找链表尾

p -> next =L2; //L2链接到L1尾部

while(q->next != L2) q = q->next;

q -> next = L1;

y741934193

2024年4月18日 00:07

void merge(Lnode *L1,Lnode *L2){

Lnode *p=L1;Lnode *q=L2;

while (p->next!=L1) p=p->next; //找到L1链尾

while (q->next!=L2) q=q->next; //找到L2链尾

p->next=L2;q->next=L1;

}

zzw1803472614

2024年3月24日 23:07

L1->rear->next = L2->head->next;

L2->rear->next=L1->head

公交车呢

2024年3月12日 20:52

void merge(Lnode *L1, Lnode *L2) {

Lnode *p = L1, *q = L2 ;

while(p->next!=L1)//找到L1链尾

p=p->next;

while(q->next!=L2)//找到L2链尾

q=q->next;

q->next=L1; p->next =L2;

}

lkjgggggoing

2024年3月1日 18:47

void Link_Two_List(LinkList &L1,LinkList &L2){

LNode *p=L1,*q=L2;

if(q->next==q) {free(L2);return;}//L2为空

while(p->next!=L1){//找到L1的尾节点

p=p->next;

}

while(q->next!=L2){//找到L2的尾节点

q=q->next;

}

q->next=p->next;

p->next=L2->next;

free(L2);

return;

}

fzh

2023年11月30日 20:17

void Connect(LinkNode* L1,LinkNode* L2)

{

LinkNode* p；

while(p->next!=L1) p=p->next;

p->next=L2;

p=p->next;

while(p->next!=L2) p=p->next;

p->next=L1；

}

gaoshipeng

2023年11月23日 16:44

1 分别遍历L1 L2 找到各自Rear结点

1 L1的rear结点next指向L2

2 L2的rear的next指向L1

void MergeCycleList(Lnode *l1,Lnode* l2)

{

Lnode* p=l1;Lnode* q=l2;

while(p->next!=l1)

{

p=p->next;

}

while(q->next!=l2)

{

q=q->next;

}

p->next=l2;q->next=l1;

}

woaixinzhou

2023年11月19日 22:24

void merge(L1,L2)

{

p = L1; q = L2;

while(p->next != L1) p = p->next;

if(q->next != L2) p->next = q->next;

while(q->next != L2) q = q->next;

q->next = L1;

return;

}

//我认为题意将L2链接到L1后应该不包括L2的头结点！头结点唯一表示链表，并不是用来存储数据的节点，所以这里进行处理

dasuanmao_11

2023年11月11日 15:29

LinkList* connectList(LinkList* L1,LinkList* L2){
//L1尾接到L2头,L2尾接到L1头
LinkList* p1 = L1->next;
LinkList* p2 = L2->next;
while(p1->next!=L1)
p1 = p1->next;
p1->next = L2;//L1尾接到L2头节点
while(p2->next!=L2)
p2 = p2->next;
p2->next = L1;//L2尾接到L1头节点
return L1;
}

山药男孩

2023年11月2日 19:41

int merge(LinkList L1,LinkList L2){

LinkList* p=L1;

LinkList* q=L2;

while(p->next==null || q->next==null){

return false;

}

while(p->next != L1){

p=p->next;

}

while(q=>next != L2){

q=q->next;

}

p->next=q;

q->next=L1;

return true;

}

山药男孩回复山药男孩： p->next = L2;

2023年11月2日 19:42

一叶

2023年10月20日 20:55

//用LinkList表示传入是一个链表，LNode表示节点，只是对同一结构的不同命名
int merge(LinkList L1, LinkList L2)
{
//避免传入的是空表
if ((L1->next == NULL) || (L2->next == NULL)) {
return false;
}
LNode *p = L1;
LNode *q = L2;
while (p->next != L1) {
p = p->next;//遍历l1尾部节点
}
while (q->next != L2) {
q = q->next;//遍历L2的尾部节点
}
p->next = L2;//将L2接入L1的表尾部
q->next = L1;//将L2的表尾连L1形成循环链表
return true;
}

南秋

2023年10月2日 21:17

//用LinkList表示传入是一个链表，LNode表示节点，只是对同一结构的不同命名
int merge(LinkList L1, LinkList L2)
{
    //避免传入的是空表
    if ((L1->next == NULL) || (L2->next == NULL)) {
        return false;
    }
    LNode *p = L1;
    LNode *q = L2;
    while (p->next != L1) {
        p = p->next;//遍历l1尾部节点
    }
    while (q->next != L2) {
        q = q->next;//遍历L2的尾部节点
    }
    p->next = L2;//将L2接入L1的表尾部
    q->next = L1;//将L2的表尾连L1形成循环链表
    return true;
}

思路：一、分别遍历得到传入循环链表的表尾

二、实现链表连接，并保证循环的特性

adidam9633

2023年9月23日 20:04

void merge(Lnode *L1, Lnode *L2) {Lnode *p = L1, *q = L2 ; while(p->next!=L1) p=p->next; while(q->next!=L2) q=q->next; q->next=L1; p->next =L2; }

yunke

2023年9月11日 20:54

思路

1.遍历找到循环链表的尾结点

2将L1的尾结点连接到L2的头结点，L2的尾结点连接到L1的头结点

void connect(struct LNode* L1, struct LNode* L2) {
    if (L1->next = NULL)
       (L2->next = NULL) {
        return FALSE;
    }
    struct LNode* r1 = L1->next;
    while (r1->next != L1) {
        r1 = r1->next;//遍历查找尾结点
    }
    struct LNode* r2 = L2->next;
    while (r2->next = L2) {
        r2 = r2->next;
    }
    r1->next = L2;
    r2->next = L1;
}

lightstar

2023年9月6日 21:56

下一个

高康

2023年7月23日 18:11

void(List &L1,List &L2)

{

List p,q;

if(L1->next&&L2->next) retutn error;

while(p->next!=L1)

{

p=p->next;
}

while(q->next!=L2)

{

q=q->next;
}

p->next=L2->next;

q->next=L1;

free(L2);

}

Syou

2023年7月21日 21:34

void merge(Lnode *L1, Lnode *L2){

Lnode *p,*q;

while(p->next != L1)

p=p->next;

while(q->next!=L2)

q=q->next;

q->next=L1; p->next =L2;

}

17563267197

2023年7月21日 07:35

voidmerge（Lnode*L1，Lnode*L2） {Lnode*p，*q； while（p->next!=L1） p=p->next； while（q->next!=L2） q=q->next； q->next=L1；p->next=L2； }

WhiteWing

2023年7月7日 22:13

L1->prior->next = L2;

L2->prior ->next = L1;

p = L1->prior;

L1->prior = L2->prior;

L2->prior = p;

hunhun

2023年6月28日 17:19

LNode* head1=L1;

LNode *tai1l=head1;

while(head1!=tail1){

tail1=tail1->next;

}

LNode* head2=L2;

LNode *tail2=head2;

while(head2!=tail2){

tail2=tail2->next;

}

tail1.next=head2;

tail2.next=head1;

Nirvana-T

2023年5月20日 18:32

void connectLinkedLists(struct ListNode* L1, struct ListNode* L2) {
    if (L1 == NULL || L2 == NULL) {
        return;
    }

    struct ListNode* L1_last = L1->next;
    while (L1_last->next != L1) {
        L1_last = L1_last->next;
    }

    struct ListNode* L2_last = L2->next;
    while (L2_last->next != L2) {
        L2_last = L2_last->next;
    }

    L1_last->next = L2;
    L2_last->next = L1;
}

Pstary

2023年4月28日 15:37

void merge(LinkList L1,LinkList L2){

LinkNode *p=L1,*q=L2;

while(p->next!=L1) p=p->next;

while(q->next!=L2) q=q->next;
q->next=L1;

p->next=L2;

}

13245372484

2023年4月1日 18:28

void mergeHa(LinkList L1, LinkList L2){
    LNode *L1Tail = L1->next, *L2Tail = L2->next;
    while (L1Tail->next != L1) L1Tail = L1->next;
    while (L2Tail->next != L2) L2Tail = L2->next;
    L1Tail->next = L2;
    L2Tail->next = L1;
}

2134713856

2022年12月17日 18:15

void merge(Lnode *L1, Lnode *L2)

{Lnode *p,*q ;

while(p->next!=L1)

p=p->next;

while(q->next!=L2)

q=q->next;

q->next=L1; p->next =L2;

}

一只发财鸭

2022年3月11日 15:14

void Merge(List *L1,List *L2)

{

List *p,*q;

p=L1;

q=L2;

while (p->next!=L1)

{

p=p->next;

}

while (q->next!=L2)

{

q=q->next;

}

p->next=L2;

q->next=L1;

print(L1);

}

冲冲冲123···

2022年2月13日 17:20

#include<stdio.h>
#include<stdlib.h>
#define M (List)malloc(sizeof(Node))
typedef struct Node{
int data;
Node* next;
}*List,Node;

//创建循环链表
List create(int n){
 int i;
 List head,tail;
 head=tail=NULL;
 for(i=n;i<n+10;i++){
 List p=M;
 p->data=i;
 if(head==NULL){
 head=p;
 tail=p;
 }else{
 tail->next=p;
 tail=p;
 }
 }
 tail->next=head;
 return head;
}
//合并两个单链表
void merge(List L1,List L2){
 List p1=L1,p2=L2;
 while(1){ //找到第一个链表的末尾
 if(p1->next==L1) break;
 p1=p1->next;
 }
 while(1){ //找到第二个链表的末尾
 if(p2->next==L2) break;
 p2=p2->next;
 }
 //开始合并
 p1->next=L2;
 p2->next=L1;
}
//打印循环链表
void print(List head){
 List p=head;
 while(1){
 printf("%d ",p->data);
 p=p->next;
 if(p==head) break;
 }
 printf("\n");
}
int main(){
 List L1=create(0);
 List L2=create(10);
 print(L1);
 merge(L1,L2);
 print(L1);
 return 0;
}

H WH

2021年12月30日 09:56

void connect(List L1，List L1）{
List *p,*q;
while(p->next!=L1){
p=p->next;}
while(q->next!=L2){
q=q->next;}
p->next=L2;
q->next=L1;
}

butler

2021年11月16日 15:06

void mergeHa(LinkList L1, LinkList L2){
    LNode *L1Tail = L1->next, *L2Tail = L2->next;
    while (L1Tail->next != L1) L1Tail = L1->next;
    while (L2Tail->next != L2) L2Tail = L2->next;
    L1Tail->next = L2;
    L2Tail->next = L1;
}

hulin

2021年9月6日 21:29

bool ConnectLinkList(LinkList &L1, LinkList L2){

LNode *p,*q;

p=L1;

q=L2;

while(p->next!=L1)

p = p->next;

while(q->next!=L2)

q = q->next;

p->next = L2;

q->next = L1;

return true;

}

Zakin

2021年3月22日 16:54

void merge(LNode *L1,LNODE *L2){
LNode *p,*q;
p = L1;
q = L2;
while(p->next != L1){
p = p->next;
}
p->next = L2;
while(q->next != L2){
q = q->next;
}
q->next = L1;
}

我超白好嘛

2020年6月15日 21:52

void Twicelist(Linklist &L1,LinkList &L2){

Linklist *Lo,*Lt;

if(L1->next==NULL||L2->next==NULL){

return ERROR;

}

Lo=L1;

Lt=L2;

while(Lo->next!=L1){

Lo=Lo->next;

}

while(Lt->next!=L2){

Lt=Lt->next;

}

Lo->next=L2;

Lt->next=L1;

return L1;

}

a575301453

2020年6月7日 17:17

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)

{

ListNode *r1=l1;

ListNode *r2=l2;

while(r1->next!=l1)

r1=r1->next;

while(r2->next!=l2)

r2=r2->next;

r1->next=l2;

r2->next=l1;

return l1;

}

[数据结构 P1074] 有两个循环链表，链头指针分别为L1和L2，要求写出算法将L2链表链到L1链表之后，且连接后仍保持循环

登录后提交答案