【数据结构】单链表第五篇

其他 2020-10-15 15:20:35 阅读次数: 0

文章目录

一、前言

二、取两单链表data相同结点存放入原链原结点中

单链表取数值相同元素——取两单链表data相同结点存放入原链原结点中

2.1 两条链递增

#include <iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
//不破坏原链条 就要新建新链条新节点    破坏原链条 就不要新建新链条
//取公共元素中，不破坏原链条，大于小于只要移动就好了，破坏原链条，大于小于要移动并且删除节点
//不破坏原链条，等于只要插入并且移动就好了  破坏原链条，等于要插入移动并删除
//不破坏原链条， 最后无操作                                          破坏原链条，最后要将三个链表多余的节点都要删除
typedef struct node{
    
    
int data;
struct node *next;
}Node,*Linklist;
//单调递增12345  13579  变为 135  递增谁小移动谁
void getsame(Linklist str1,Linklist str2){
    
    //取data相同  其余不同删除  原链源节点  尾插法
Linklist pa=str1->next,pb=str2->next;
Linklist r=str1;
while(pa&&pb){
    
    
    if(pa->data==pb->data){
    
    
        r->next=pa;
        r=pa;
        pa=pa->next;
        Linklist u=pb;
        pb=pb->next;//先移动后删除
        free(u);
    }else if(pa->data<pb->data){
    
    
    Linklist u=pa;
    pa=pa->next;
    free(u);
    }else {
    
    
    Linklist u=pb;
    pb=pb->next;
    free(u);
    }
}
while(pa){
    
    
     Linklist u=pa;
    pa=pa->next;
    free(u);
}
while(pb){
    
    
      Linklist u=pb;
    pb=pb->next;
    free(u);
}
r->next=NULL;
free(str2);
}
int main()
{
    
    
    int a[5];
    for (int i=0;i<5;i++)
    cin>>a[i];
    Linklist first=new Node;
    Linklist r=first;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=a[i];
        r->next=s;
        r=s;
 
    }
    r->next=NULL;
    Linklist p=first->next;
    while(p){
    
    
        cout<<p->data;
        p=p->next;
    }
cout<<endl;
 
 
    int b[5];
    for (int i=0;i<5;i++)
    cin>>b[i];
    Linklist first2=new Node;
    Linklist r2=first2;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=b[i];
        r2->next=s;
        r2=s;
 
    }
    r2->next=NULL;
     p=first2->next;
    while(p){
    
    
        cout<<p->data;
        p=p->next;
    }
cout<<endl;
 
getsame(first,first2);
 
p=first->next;//重置p
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
    return 0;
}

运行结果：

1 2 3 4 5         //输入1
12345             //中间打印
1 3 5 7 9         //输入2
13579             //中间打印
135               //输出相同元素

2.2 两条链递减

#include <iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
//不破坏原链条 就要新建新链条新节点    破坏原链条 就不要新建新链条
//取公共元素中，不破坏原链条，大于小于只要移动就好了，破坏原链条，大于小于要移动并且删除节点
//不破坏原链条，等于只要插入并且移动就好了  破坏原链条，等于要插入移动并删除
//不破坏原链条， 最后无操作                                          破坏原链条，最后要将三个链表多余的节点都要删除
typedef struct node{
    
    
int data;
struct node *next;
}Node,*Linklist;
 
//两个递减 两个输入 54321  97531 一个输出 531  递减谁大移动谁   两个输入 一个输出  原链源节点  要删除   新链新节点 原链不变 要新建
void getsame2(Linklist str1,Linklist str2){
    
    
Linklist pa=str1->next,pb=str2->next;
Linklist r=str1;
while(pa&&pb){
    
    
    if(pa->data==pb->data){
    
    
        r->next=pa;
        r=pa;
        pa=pa->next;
        Linklist u=pb;
        pb=pb->next;
        free(u);
    }else if(pa->data>pb->data){
    
    
    Linklist u=pa;
    pa=pa->next;
    free(u);
    }else {
    
    
    Linklist u=pb;
    pb=pb->next;
    free(u);
    }
}
while(pa){
    
    
     Linklist u=pa;
    pa=pa->next;
    free(u);
}
while(pb){
    
    
      Linklist u=pb;
    pb=pb->next;
    free(u);
}
r->next=NULL;
free(str2);
}
int main()
{
    
    
    int a[5];
    for (int i=0;i<5;i++)
    cin>>a[i];
    Linklist first=new Node;
    Linklist r=first;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=a[i];
        r->next=s;
        r=s;
 
    }
    r->next=NULL;
    Linklist p=first->next;
    while(p){
    
    
        cout<<p->data;
        p=p->next;
    }
cout<<endl;
 
 
    int b[5];
    for (int i=0;i<5;i++)
    cin>>b[i];
    Linklist first2=new Node;
    Linklist r2=first2;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=b[i];
        r2->next=s;
        r2=s;
 
    }
    r2->next=NULL;
     p=first2->next;
    while(p){
    
    
        cout<<p->data;
        p=p->next;
    }
cout<<endl;
 
getsame2(first,first2);
 
p=first->next;//重置p
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
    return 0;
}

运行结果：

5 4 3 2 1              //输入1
54321                  //中间打印
9 7 5 3 1              //输入2
97531                  //中间打印 
531                    //输出相同元素

2.3 一条链递增，一条链递减

#include <iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
//不破坏原链条 就要新建新链条新节点    破坏原链条 就不要新建新链条
//取公共元素中，不破坏原链条，大于小于只要移动就好了，破坏原链条，大于小于要移动并且删除节点
//不破坏原链条，等于只要插入并且移动就好了  破坏原链条，等于要插入移动并删除
//不破坏原链条， 最后无操作                                          破坏原链条，最后要将三个链表多余的节点都要删除
typedef struct node{
    
    
int data;
struct node *next;
}Node,*Linklist;
 
//一个递增 一个递减 两个输入 12345  97531 变成 12345 13579  一个输出 135  递增谁小移动谁
Linklist getsame3(Linklist str1,Linklist str2){
    
    
Linklist pa=str1->next,pb=str2->next;
str2->next=NULL;
while(pb){
    
    
    Linklist u=pb->next;
    pb->next=str2->next;
    str2->next=pb;
    pb=u;
}
 
pb=str2->next;//重置pb
Linklist r=str1;
while(pa&&pb){
    
    
    if(pa->data==pb->data){
    
    
        r->next=pa;
        r=pa;
        pa=pa->next;
 
        Linklist u=pb;
        pb=pb->next;
        free(u);
    }else if(pa->data<pb->data){
    
    
    Linklist u=pa;
    pa=pa->next;
    free(u);
    }else {
    
    
    Linklist u=pb;
    pb=pb->next;
    free(u);
    }
}
while(pa){
    
    
     Linklist u=pa;
    pa=pa->next;
    free(u);
}
while(pb){
    
    
    Linklist u=pb;
    pb=pb->next;
    free(u);
}
r->next=NULL;
free(str2);
}
int main()
{
    
    
    int a[5];
    for (int i=0;i<5;i++)
    cin>>a[i];
    Linklist first=new Node;
    Linklist r=first;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=a[i];
        r->next=s;
        r=s;
 
    }
    r->next=NULL;
    Linklist p=first->next;
    while(p){
    
    
        cout<<p->data;
        p=p->next;
    }
cout<<endl;
 
 
    int b[5];
    for (int i=0;i<5;i++)
    cin>>b[i];
    Linklist first2=new Node;
    Linklist r2=first2;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=b[i];
        r2->next=s;
        r2=s;
 
    }
    r2->next=NULL;
     p=first2->next;
    while(p){
    
    
        cout<<p->data;
        p=p->next;
    }
cout<<endl;
 
getsame3(first,first2);
 
p=first->next;//重置p
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
    return 0;
}

运行结果：

1 2 3 4 5          //输入1
12345              //中间打印    
9 7 5 3 1          //输入2 
97531              //中间打印
135                //输出相同结点

小结：单链表取数值相同元素——取两单链表data相同结点存放入原链原结点中

三、取两单链表data相同结点存放入新链新结点中

单链表取数值相同元素——取两单链表data相同结点存放入新链新结点中

3.1 两条单调递增的链 求公共元素

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
typedef struct node{
    
    
int data;
struct node *next;
}Node,*Linklist;
//取公共元素不破坏原链
//两条单调递增的链 求公共元素  两条单调递减  一条递增 一条递减    一条递减 一条递增
Linklist get_same1(Linklist str1,Linklist str2){
    
    
Linklist pa=str1->next,pb=str2->next;
Linklist str3=new Node;//要求不破坏str1 str2 就要新建一条链  以后凡是要求不破坏原链的头插尾插都要新建一条链
Linklist r=str3;
while(pa&&pb){
    
    
    if(pa->data<pb->data){
    
    //输入  12345  13579  变为 135   所以尾插法  递增所以谁小移动谁
        pa=pa->next;
    }else if(pa->data<pb->data){
    
    
    pb=pb->next;
    }else{
    
    
        //这里要求不破坏原链  所有尾插的时候要是用 新节点s  不能使用原节点 p    以后记住 不破坏原链条就是新链新节点
        Linklist s=new Node;
        s->data=pa->data;
    r->next=s;
    r=s;
 
    pa=pa->next;
    pb=pb->next;
 
    }
}
r->next=NULL;
return str3;
}
int main()
{
    
    
    int a[5];
    for (int i=0;i<5;i++)
        cin>>a[i];
    Linklist first=new Node;
    Linklist r=first;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
    Linklist p=first->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
    cout<<endl;
 
    int b[5];
    for (int i=0;i<5;i++)
        cin>>b[i];
    Linklist first2=new Node;
    Linklist r2=first2;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=b[i];
        r2->next=s;
        r2=s;
    }
    r2->next=NULL;
     p=first2->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
    cout<<endl;
 
 
    Linklist result=get_same1(first,first2);
    p=result->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
 
    return 0;
}

运行结果：

1 2 3 4 5             输入
1 2 3 4 5             中间打印
1 3 5 7 9             输入
1 3 5 7 9             中间打印
1 3 5                 输出

3.2 两条单调递减的链 求公共元素

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
typedef struct node{
    
    
int data;
struct node *next;
}Node,*Linklist;
//两条递减  输入  54321 97531  输出 531  所以尾插法 所以谁大移动谁
Linklist get_same2(Linklist str1,Linklist str2){
    
    
Linklist pa=str1->next,pb=str2->next;
Linklist str3=new Node;
Linklist r=str3;
while(pa&&pb){
    
    
    if(pa->data>pb->data){
    
    //输入  54321 97531  输出 531  递减所以谁大移动谁
        pa=pa->next;
    }else if(pa->data<pb->data){
    
    
    pb=pb->next;
    }else {
    
    
    Linklist s=new Node;
    s->data=pa->data;
    r->next=s;
    r=s;
    pa=pa->next;
    pb=pb->next;
    }
}
r->next=NULL;
return str3;
}
int main()
{
    
    
    int a[5];
    for (int i=0;i<5;i++)
        cin>>a[i];
    Linklist first=new Node;
    Linklist r=first;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
    Linklist p=first->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
    cout<<endl;
 
    int b[5];
    for (int i=0;i<5;i++)
        cin>>b[i];
    Linklist first2=new Node;
    Linklist r2=first2;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=b[i];
        r2->next=s;
        r2=s;
    }
    r2->next=NULL;
     p=first2->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
    cout<<endl;
 
 
    Linklist result=get_same2(first,first2);
    p=result->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
 
    return 0;
}

运行结果：

5 4 3 2 1       输入
5 4 3 2 1       中间打印
9 7 5 3 1       输入
9 7 5 3 1       中间打印
5 3 1           输出

3.3 一个递增链，一个递减链，求公共元素

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
typedef struct node{
    
    
int data;
struct node *next;
}Node,*Linklist;
//一个递增  一个递减  12345   97531  变成 54321  97531提取 531
Linklist get_same3(Linklist str1,Linklist str2){
    
    
Linklist pa=str1->next,pb=str2->next;
//对str1就地逆置
str1->next=NULL;
 
while(pa){
    
    
    Linklist u=pa->next;
    pa->next=str1->next;
    str1->next=pa;
    pa=u;
}
pa=str1->next;//  54321  97531   提取出 531  递减谁大移动谁
Linklist str3=new Node;
Linklist r=str3;
while(pa&&pb){
    
    
    if(pa->data>pb->data){
    
    
        pa=pa->next;
    }else if(pa->data<pb->data){
    
    
    pb=pb->next;
    }else {
    
    
    Linklist s=new Node;
    s->data=pa->data;
    r->next=s;
    r=s;
    pa=pa->next;
    pb=pb->next;
    }
}
r->next=NULL;
return str3;
}
int main()
{
    
    
    int a[5];
    for (int i=0;i<5;i++)
        cin>>a[i];
    Linklist first=new Node;
    Linklist r=first;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
    Linklist p=first->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
    cout<<endl;
 
    int b[5];
    for (int i=0;i<5;i++)
        cin>>b[i];
    Linklist first2=new Node;
    Linklist r2=first2;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=b[i];
        r2->next=s;
        r2=s;
    }
    r2->next=NULL;
     p=first2->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
    cout<<endl;
 
 
    Linklist result=get_same3(first,first2);
    p=result->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
 
    return 0;
}

运行结果：

1 2 3 4 5    输入
1 2 3 4 5    中间打印
9 7 5 3 1    输入
9 7 5 3 1    中间打印 
5 3 1        输出

3.4 一个递减链，一个递增链，求公共元素

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
typedef struct node{
    
    
int data;
struct node *next;
}Node,*Linklist;
//一个递减  一个递增  54321  13579  变为 12345  13579  提取 135   递增谁小移动谁
//原链条递增谁小移动谁  递减谁大移动谁  无论合并链条还是取data公共元素（破坏或不破坏原链条）  都是如此
Linklist get_same4(Linklist str1,Linklist str2){
    
    
Linklist pa=str1->next,pb=str2->next;
//54321 就地逆置为 12345
str1->next=NULL;
while(pa){
    
    
    Linklist u=pa->next;
    pa->next=str1->next;
    str1->next=pa;
    pa=u;
}
pa=str1->next;//重置pa
// 12345 13579  变为 135  所以尾插法
Linklist str3=new Node;
Linklist r=str3;
while(pa&&pb){
    
    
    if(pa->data<pb->data){
    
    
        pa=pa->next;
    }else if(pa->data>pb->data){
    
    
    pb=pb->next;
    }else {
    
    
    Linklist s=new Node;
    s->data=pa->data;
    r->next=s;
    r=s;
    pa=pa->next;
    pb=pb->next;
    }
}
r->next=NULL;
return str3;
}
int main()
{
    
    
    int a[5];
    for (int i=0;i<5;i++)
        cin>>a[i];
    Linklist first=new Node;
    Linklist r=first;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
    Linklist p=first->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
    cout<<endl;
 
    int b[5];
    for (int i=0;i<5;i++)
        cin>>b[i];
    Linklist first2=new Node;
    Linklist r2=first2;
    for (int i=0;i<5;i++){
    
    
        Linklist s=new Node;
        s->data=b[i];
        r2->next=s;
        r2=s;
    }
    r2->next=NULL;
     p=first2->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
    cout<<endl;
 
 
    Linklist result=get_same4(first,first2);
    p=result->next;
    while(p){
    
    
        cout<<p->data;
        cout<<" ";
        p=p->next;
    }
 
    return 0;
}

运行结果：

5 4 3 2 1     输入
5 4 3 2 1     中间打印
1 3 5 7 9     输入
1 3 5 7 9     中间打印
1 3 5         输出

小结：单链表取数值相同元素——取两单链表data相同结点存放入新链新结点中，充分考虑了四种情况，熟练使用最基本是头插尾插

四、2个单链表寻找共用结点

2个单链表寻找共用结点(是共用的同一结点，不是data相同的结点)，并输出共用结点的第一个结点

2个单链表寻找共用结点(是共用的同一结点，不是data相同的结点)，并输出第一个共用结点
第一步，先构造a b 两个链表，然后新建一个c 链表，a b 后面均接入c链表，形成二条新的链表，这就是完成初始工作；
第二步，因为当出现第一个二条链共用的结点时，二条链后面的所有结点都相同，二条链后面的长度也相同；
在函数中计算二条新链表的长度，然后将其移动使其尾对齐，然后开始寻找共用结点，找到后输出第一个共用结点。

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
typedef struct node{
    
    
    int data;
    struct node *next;
}Node,*Linklist;
int mylength(Linklist str1){
    
    
Linklist p=str1->next;
int mycount=0;
while(p){
    
    
    p=p->next;
    mycount++;
}
return mycount;
}
Linklist hebing(Linklist str1,Linklist str2){
    
    
Linklist pa,pb;
int lena=mylength(str1);
int lenb=mylength(str2);
cout<<"lena: ";
cout<<lena<<endl;
cout<<"lenb: ";
cout<<lenb<<endl;
for(pa=str1;lena>lenb;lena--)
    pa=pa->next;
for (pb=str2;lenb>lena;lenb--)
    pb=pb->next;
while(pa->next!=NULL&&pa->next!=pb->next){
    
    
    pa=pa->next;
    pb=pb->next;
}
return pa->next;
}
int main()// 5 4 3   12345   1234   789
{
    
    
int a[5];
for (int i=0;i<5;i++)
    cin>>a[i];
Linklist first=new Node;
Linklist r=first;
for (int i=0;i<5;i++){
    
    
    Linklist s=new Node;
    s->data=a[i];
    r->next=s;
    r=s;
}
r->next=NULL;
Linklist p=first->next;
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
int b[4];
for(int i=0;i<4;i++)
    cin>>b[i];
Linklist first2=new Node;
Linklist r2=first2;
for(int i=0;i<4;i++){
    
    
    Linklist s=new Node;
    s->data=b[i];
    r2->next=s;
    r2=s;
}
r2->next=NULL;
p=first2->next;
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
 int c[3];
 for (int i=0;i<3;i++)
    cin>>c[i];
 Linklist first3=new Node;
 Linklist r3=first3;
 for (int i=0;i<3;i++){
    
    
    Linklist s=new Node;
    s->data=c[i];
    r3->next=s;
    r3=s;
 }
 r3->next=NULL;
 p=first3->next;
 while(p){
    
    
    cout<<p->data;
    p=p->next;
 }
 cout<<endl;
 
 Linklist ra=first;
 while(ra->next!=NULL)
    ra=ra->next;
 ra->next=first3->next;
 
 p=first->next;
 while(p){
    
    
    cout<<p->data;
    p=p->next;
 }
    cout<<endl;
 
 Linklist rb=first2;
 while(rb->next!=NULL)
    rb=rb->next;
 
 
 rb->next=first3->next;
 
 p=first2->next;
 while(p){
    
    
    cout<<p->data;
    p=p->next;
 }
    cout<<endl;
 
 
 
 
 Linklist result=hebing(first,first2);
 cout<<result->data<<endl;
 
 
    return 0;
}

运行结果：

在这里插入图片描述

小结：2个单链表寻找共用结点(是共用的同一结点，不是data相同的结点)，并输出第一个共用结点

五、n个单链表寻找共用结点

n个单链表寻找共用结点(是共用的同一结点，不是data相同的结点)，并输出共用结点的第一个结点

n个单链表寻找共用结点(是共用的同一结点，不是data相同的结点)，并输出第一个共用结点
第一步，先构造a b c 三个链表，然后新建一个d 链表，a b c 后面均接入d 链表，形成三条新的链表，这就是完成初始工作；
第二步，因为当出现第一个三条链共用的结点时，三条链后面的所有结点都相同，三条链后面的长度也相同；
在函数中计算三条新链表的长度，然后将其移动使其尾对齐，然后开始寻找共用结点，找到后输出第一个共用结点。

#include <iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
//单链表
typedef struct node {
    
    
int data;
struct node *next;
}Node,*Linklist;
//合并   next    合并  分开   data  next
int mylength(Linklist str1){
    
    
Linklist p=str1->next;
int mylen=0;//这里一定要有初始值 否则长度出错
while(p){
    
    
    p=p->next;mylen++;
}
return mylen;
}
Linklist mycommon(Linklist str1,Linklist str2,Linklist str3){
    
    //关键是尾部对齐 good
Linklist pa,pb,pc;
int mylena=mylength(str1);
int mylenb=mylength(str2);
int mylenc=mylength(str3);
cout<<"mylena: ";
cout<<mylena<<endl;
cout<<"mylenb: ";
cout<<mylenb<<endl;
cout<<"mylenc: ";
cout<<mylenc<<endl;
for ( pa=str1;mylena>mylenb||mylena>mylenc;mylena--)//这里是或  取到最小
    pa=pa->next;
for (pb=str2;mylenb>mylena||mylenb>mylenc;mylenb--)
    pb=pb->next;
    for (pc=str3;mylenc>mylena||mylenc>mylenb;mylenc--)
        pc=pc->next;
//为NULL  或者 三个全部相等  退出
while(pa->next!=NULL&&(pa->next!=pb->next||pc->next!=pb->next||pa->next!=pc->next)){
    
    //这里是next节点相同不是data 相同怎么输入  str1 str2 str3  连接
    pa=pa->next;pb=pb->next;pc=pc->next;
}
return pa->next;//当pa->next==pb->next  返回pa->next;
}
int main()// 5 4 3  3
{
    
    
   int a[5];
   for (int i=0;i<5;i++)
    cin>>a[i];
   Linklist first=new Node;
   Linklist r=first;
   for (int i=0;i<5;i++){
    
    
    Linklist s=new Node;
    s->data=a[i];
    r->next=s;
    r=s;
   }
   r->next=NULL;
   Linklist p=first->next;
   while(p){
    
    
    cout<<p->data;
    p=p->next;
   }
   cout<<endl;
 
    int b[4];
   for (int i=0;i<4;i++)
    cin>>b[i];
   Linklist first2=new Node;
   Linklist r2=first2;
   for (int i=0;i<4;i++){
    
    
    Linklist s=new Node;
    s->data=b[i];
    r2->next=s;
    r2=s;
   }
   r2->next=NULL;
    p=first2->next;
   while(p){
    
    
    cout<<p->data;
    p=p->next;
   }
   cout<<endl;
 
    int c[3];
   for (int i=0;i<3;i++)
    cin>>c[i];
   Linklist first3=new Node;
   Linklist r3=first3;
   for (int i=0;i<3;i++){
    
    
    Linklist s=new Node;
    s->data=c[i];
    r3->next=s;
    r3=s;
   }
   r3->next=NULL;
   p=first3->next;
   while(p){
    
    
    cout<<p->data;
    p=p->next;
   }
   cout<<endl;
 
    int d[3];
   for (int i=0;i<3;i++)
    cin>>d[i];
   Linklist first4=new Node;
   Linklist r4=first4;
   for (int i=0;i<3;i++){
    
    
    Linklist s=new Node;
    s->data=d[i];
    r4->next=s;
    r4=s;
   }
   r4->next=NULL;
   p=first4->next;
   while(p){
    
    
    cout<<p->data;
    p=p->next;
   }
   cout<<endl;
 
 
 
Linklist ra=first;
while(ra->next!=NULL)
    ra=ra->next;
ra->next=first4->next;
 
p=first->next;
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
Linklist rb=first2;
while(rb->next!=NULL)
    rb=rb->next;
rb->next=first4->next;
 
p=first2->next;
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
Linklist rc=first3;
while(rc->next!=NULL){
    
    
    rc=rc->next;
}
rc->next=first4->next;
 
p=first3->next;
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
 
Linklist result=mycommon(first,first2,first3);
cout<<"result->data: ";
cout<<result->data<<endl;
    return 0;
}

运行结果：

在这里插入图片描述

n个单链表寻找共用结点(是共用的同一结点，不是data相同的结点)，并输出第一个共用结点

六、循环双链表判断链表是否对称

#include <iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
typedef struct node{
    
    //循环双链表和双链表定义相同
int  data;
struct node *next;
struct node *prior;
}Node,*Linklist;
int duichen(Linklist str1){
    
    
Linklist pa=str1->next,pb=str1->prior;//一个是str1->next 一个是str1->prior 没有一个是str1
while(pa!=pb&&pb->next!=pa){
    
    
    if(pa->data==pb->data){
    
    
        pa=pa->next;
        pb=pb->prior;
    }
    else
        return -1;
}
return 1;
}
int main()
{
    
    
   int n;
   cin>>n;
   int a[100];
   for (int i=0;i<n;i++)
    cin>>a[i];
   Linklist first=new Node;
   first->next=first->prior=first;//初始化 双向循环链表   他的插入是一个头插
 
   Linklist p=first;
   for(int i=0;i<n;i++){
    
    
    Linklist s=new Node;
    s->data=a[i];
 
    s->next=p->next;
    s->prior=p;
    p->next->prior=s;
    p->next=s;
 
 
   }
 
 p=first->next;
 
   while(p!=first){
    
    
    //移动两个 pq  首末   p=first->next,q=first->prior;while(p!=q&&q->next!=p)  移动一个 p=first->next,while(p!=q)
    cout<<p->data;
    p=p->next;
   }
 
 
   int result=duichen(first);
   if(result==1)
    cout<<"对称"<<endl;
   else
    cout<<"不对称"<<endl;
 
 
    return 0;
}

运行结果：

6
1 2 3 3 2 1
123321对称

6
1 2 3 2 2 1
122321不对称

七、小结

单链表第五篇，完成了。

天天打码，天天进步！！！

猜你喜欢

转载自blog.csdn.net/qq_36963950/article/details/109007611
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022