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

一、前言

二、单链表连续子序列判断

单链表——连续子序列判断是单链表基本操作之一，使用循环，当两工作指针所指结点数值相同，各自移动，直至不同为止。

#include <iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
typedef struct node
{
    
    
    int data;
    struct node *next;
} Node,*Linklist;
int sequence(Linklist str1,Linklist str2) //查询类
{
    
    
    Linklist pa=str1->next,pb=str2->next;
    Linklist pre=str1;
    while(pa&&pb)
    {
    
    
//这里while(pa)  或者 while(pa&&pb) 都没有关系  如果while(pa)  就是pa完成之后  结束循环  如果while(pa&&pb) 当pb==NULL跳出时成功  当pa==NULL跳出时 失败
        if(pa->data==pb->data)
        {
    
    
            pa=pa->next;
            pb=pb->next;
        }
        else
        {
    
    
            pre=pre->next;
            pa=pre;
            pb=str2->next;
        }
 
    }
    if(pb==NULL)
        return 1;
    return -1;
}
int main()
{
    
    
    int a[6];// 1 2 3 4 5  6    3 4 5   3 4 6
    for (int i=0; i<6; i++)
        cin>>a[i];
    Linklist first=new Node;
    Linklist r=first;
    for (int i=0; i<6; 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[3];// 1 2 3 4 5  6    3 4 5   3 4 6
    for (int i=0; i<3; i++)
        cin>>b[i];
    Linklist first2=new Node;
    Linklist r2=first2;
    for (int i=0; i<3; 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 result=sequence(first,first2);
    if(result==1)
        cout<<"B序列是A序列的连续子序列"<<endl;
    else
        cout<<"B序列不是A序列的连续子序列"<<endl;
 
    return 0;
}

运行结果：

1 2 3 4 5 6                          输入
123456                               中间打印
3 4 5                                输入
345                                  中国打印
B序列是A序列的连续子序列               输出

1 2 3 4 5 6                        输入
123456                             中间打印
3 4 6                              输入
346                                中间打印
B序列不是A序列的连续子序列           输出

三、循环单链表之间的连接

若干的小的循环单链表将首尾拆开，成为了一个个小的单链表，然后连接成为一个大的单链表，最后大的单链表合并，就成了大的循环单链表

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
typedef struct node{
    
    
int data;
struct node *next;
}Node,*Linklist;
//循环链表link  关键是为了找到尾巴
Linklist mylink(Linklist str1,Linklist str2,Linklist str3){
    
    
Linklist ra=str1,rb=str2,rc=str3;//从第一个开始遍历尾巴
while(ra->next!=str1)
    ra=ra->next;
while(rb->next!=str2)
    rb=rb->next;
while(rc->next!=str3)
    rc=rc->next;
ra->next=str2->next;//中间那个str2不要了
 
rb->next=str3->next;//中间那个str3不要了
rc->next=str1;//返回first 主函数中while(p!=first)  这里一定是str1  不能是str1->next
return str1;
}
 
int main()
{
    
    //输入 12345  678910
int a[5];
for (int i=0;i<5;i++)
cin>>a[i];
 
Linklist first=new Node;
first->next=first;//单链循环  空表
 
for (int i=0;i<5;i++){
    
    //对于循环单链表和循环双链表  初始化使用first和p 是一样的 因为 p=first->next=first
    Linklist s=new Node;
    s->data=a[i];
   s->next=first->next;
   first->next=s;
}
Linklist p=first->next;
 
while(p!=first){
    
    
    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;
first2->next=first2;//单链循环  空表
for (int i=0;i<5;i++){
    
    
    Linklist s=new Node;
    s->data=b[i];
   s->next=first2->next;
   first2->next=s;
}
 p=first2->next;
while(p!=first2){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
 
int c[5];
for (int i=0;i<5;i++)
cin>>c[i];
Linklist first3=new Node;
first3->next=first3;//单链循环  空表
for (int i=0;i<5;i++){
    
    
    Linklist s=new Node;
    s->data=c[i];
   s->next=first3->next;
   first3->next=s;
}
 p=first3->next;
while(p!=first3){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
 
mylink(first,first2,first3);
 
 
 
p=first->next;
while(p!=first){
    
    //连接中间确实有一个值的 不要怀疑     连接三个表 中间有两个值
    cout<<p->data;
    p=p->next;
}
 
    return 0;
}

运行结果：

将循环单链的拆分和合并结合到一起，加深学习

四、循环双链表之间的连接

若干的小的循环双链表将首尾拆开，成为了一个个小的双链表，然后连接成为一个大的双链表，最后大的双链表合并，就成了大的循环双链表

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
//单链循环变成双链条循环   结构体变了   初始化变了   链结函数变了  打印加一个
typedef struct node{
    
    
int data;
struct node *next;
struct node *prior;
}Node,*Linklist;
//循环链表link  关键是为了找到尾巴
Linklist mylink(Linklist str1,Linklist str2,Linklist str3){
    
    
Linklist ra=str1,rb=str2,rc=str3;//从第一个开始遍历尾巴
while(ra->next!=str1)
    ra=ra->next;
while(rb->next!=str2)
    rb=rb->next;
while(rc->next!=str3)
    rc=rc->next;
ra->next=str2->next;//中间那个str2不要了
str2->next->prior=ra;
 
rb->next=str3->next;//中间那个str3不要了
str3->next->prior=rb;
rc->next=str1;//返回first 主函数中while(p!=first)  这里一定是str1  不能是str1->next
str1->prior=rc;
return str1;
}
 
int main()
{
    
    //输入 12345  678910
int a[5];
for (int i=0;i<5;i++)
cin>>a[i];
 
Linklist first=new Node;
first->next=first->prior=first;//单链循环  空表
Linklist p=first->next;
for (int i=0;i<5;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){
    
    
    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;
first2->next=first2->prior=first2;//单链循环  空表
 p=first2->next;
for (int i=0;i<5;i++){
    
    
    Linklist s=new Node;
    s->data=b[i];
 
   s->next=p->next;
   s->prior=p;
   p->next->prior=s;
   p->next=s;
 
 
}
 p=first2->next;
 
while(p!=first2){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
 
int c[5];
for (int i=0;i<5;i++)
cin>>c[i];
 
Linklist first3=new Node;
first3->next=first3->prior=first3;//单链循环  空表
 p=first3->next;
for (int i=0;i<5;i++){
    
    
    Linklist s=new Node;
    s->data=c[i];
 
   s->next=p->next;
   s->prior=p;
   p->next->prior=s;
   p->next=s;
 
 
}
 p=first3->next;
 
while(p!=first3){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
mylink(first,first2,first3);
 
 
//12345679101112131415
p=first->next;
while(p!=first){
    
    //连接中间确实有一个值的 不要怀疑     连接三个表 中间有两个值
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
//151413121110987654321
p=first->prior;
while(p!=first){
    
    
    cout<<p->data;
    p=p->prior;
}
    return 0;
}

运行结果：

将循环双链的拆分和合并结合到一起，加深学习

五、单链表之间的连接

若干的小的单链表组合起来，连接成为一个大的单链表

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
//单链表连接
typedef struct node {
    
    
int data;
struct node *next;
}Node,*Linklist;
void mylink(Linklist str1,Linklist str2,Linklist  str3){
    
    
Linklist ra=str1,rb=str2,rc=str3;
while(ra->next!=NULL){
    
    //非循环链表判断是否到达最后一个元素
    ra=ra->next;
}
while(rb->next!=NULL){
    
    //非循环链表判断是否到达最后一个元素
    rb=rb->next;
}
 
ra->next=str2->next;//跳过 str2
rb->next=str3->next;//跳过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;
    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;
 
 
int c[5];
for (int i=0;i<5;i++)
    cin>>c[i];
Linklist first3=new Node;
Linklist r3=first3;
for (int i=0;i<5;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;
 
 
mylink(first,first2,first3);
//打印单链表
p=first->next;
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
    return 0;
 
}

运行结果：

体现了单链表尾指针的设置，加深学习

六、双链表之间的连接

若干的小的双链表组合起来，连接成为一个大的双链表

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
//单链表连接
typedef struct node {
    
    
int data;
struct node *next;
struct node *prior;
}Node,*Linklist;
Linklist mylink(Linklist str1,Linklist str2,Linklist  str3){
    
    
Linklist ra=str1,rb=str2,rc=str3;
while(ra->next!=NULL){
    
    //非循环链表判断是否到达最后一个元素
    ra=ra->next;
}
while(rb->next!=NULL){
    
    //非循环链表判断是否到达最后一个元素
    rb=rb->next;
}
while(rc->next!=NULL){
    
    
    rc=rc->next;
}
ra->next=str2->next;//跳过 str2
str2->next->prior=ra;
rb->next=str3->next;//跳过str3
str3->next->prior=rb;
return rc;
}
int main()
{
    
    
int a[5];
for (int i=0;i<5;i++)
    cin>>a[i];
Linklist first=new Node;//双链表头插法   和双链条循环链表一样      单链循环链表插入和单链表一样
 
first->next=first->prior=NULL;
 
for (int i=0;i<5;i++){
    
    //循环单链表的插入和单链表插入一模一样  但是双链表的插入比循环双链表插入多一个判断
    Linklist s=new Node;
    s->data=a[i];
 
    s->next=first->next;//这里为空没有关系  第二句和第四句是两条线
    s->prior=first;
    if(first->next!=NULL)
    first->next->prior=s;//空指针异常
    first->next=s;
}
 
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;//双链表头插法   和双链条循环链表一样      单链循环链表插入和单链表一样
first2->next=first2->prior=NULL;
for (int i=0;i<5;i++){
    
    循环单链表的插入和单链表插入一模一样  但是双链表的插入比循环双链表插入多一个判断
    Linklist s=new Node;
    s->data=b[i];
 
    s->next=first2->next;//这里为空没有关系  第二句和第四句是两条线
    s->prior=first2;
    if(first2->next!=NULL)
    first2->next->prior=s;
    first2->next=s;
}
 
p=first2->next;
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
int c[5];
for (int i=0;i<5;i++)
    cin>>c[i];
Linklist first3=new Node;//双链表头插法   和双链条循环链表一样      单链循环链表插入和单链表一样
first3->next=first3->prior=NULL;
for (int i=0;i<5;i++){
    
    //循环单链表的插入和单链表插入一模一样  但是双链表的插入比循环双链表插入多一个判断
    Linklist s=new Node;
    s->data=c[i];
 
    s->next=first3->next;//这里为空没有关系  第二句和第四句是两条线
    s->prior=first3;
    if(first3->next!=NULL)
    first3->next->prior=s;
    first3->next=s;
}
 
p=first3->next;
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
 
 
 
Linklist result=mylink(first,first2,first3);
//打印单链表
p=first->next;
while(p){
    
    
    cout<<p->data;
    p=p->next;
}
cout<<endl;
p=result;
while(p!=first){
    
    //这里不要打印first
    cout<<p->data;
    p=p->prior;
}
 
    return 0;
 
}

运行结果：

体现了双链表首尾指针的设置，加深学习

七、小结

单链表第三篇，完成了。

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