【王道数据结构编程题】 - 链表代码题

已于 2022-11-19 15:05:37 修改
阅读量1.3k 收藏 18
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法 文章标签： 数据结构 链表 算法 c++
于 2022-06-20 16:47:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56051805/article/details/125375272
本文详细介绍了如何在单链表中进行删除特定值、逆序输出、删除区间元素、合并递减排序、查找公共节点等操作，包括带头节点和不带头节点的情况。通过实例代码演示了这些高级链表技巧，适用于数据结构与算法的学习者。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

1.设计一个递归算法，删除不带头节点的单链表L中所有值为x的节点。

2.在带头节点的单链表L中，删除所有制为x的节点，并释放其空间，假设置为x的节点不唯一，试编写算法以实现上述操作。

3.设L为带头节点的单链表，编写算法实现从尾到头反向输出每个节点的值。

4.试编写在带头节点的单链表L这删除一个最小值节点的高效算法(假设最小值节点是唯一的)。

5.试着编写算法将带头节点的单链表就地逆置，所谓“就地”就是辅助空间复杂度为O(1)。

6.有一个带头节点的单链表L，设计一个算法使其元素递增有序。

7.设在一个带表头节点的单链表中所有元素节点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值(作为函数参数给出)之间的元素的元素(若存在)。

8.给定两个单链表，编写算法找出两个链表的公共节点。

9.给定一个带表头节点的单链表，设head为头指针，节点结构为(data , next)，data为整型元素，next为指针，试着写出算法：按递增次序输出单链表中各个节点的数据元素，并且释放节点所占的存储空间(要求：不允许使用数组作为辅助空间)。

10.将一个带头节点的单链表A分解为两个带头节点的单链表A和B，使得A表中含有原表中序号为奇数的元素，而B表中含有原表中序号为偶数的元素，且保持其相对顺序不变。

11.设C={a1,b1,a2,b2,...,an,bn}为线性表，采用带头节点的hc单链表存放，设计一个就地算法，将其拆分为两个线性表，使得A={a1,a2,...,an}，B={bn,...,b2,b1}。 

12.在一个递增有序的线性表中，有数值相同的元素存在。若存储方式为单链表，设计算法去掉数值相同的元素，使得表中不再有重复的元素，例如{7,10,10,21,30,42,42,42,51,70}将其变为{7,10,21,30,42,51,70}。 

13假设有两个按元素值递增次序排列的线性表，均以单链表形式存储，请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原来的两个单链表的节点存放归并后的单链表。 

14.设A和B是两个单链表(带头节点)，其中元素递增有序。设计一个算法从A和B中的公共元素产生单链表C，要求不破坏A,B的节点。 

15.已知两个链表A和B分别表示两个集合，其元素递增排列。编制函数，求A与B的交集，并存放于A链表中。 

16.两个整数序列A=a1,a2,...,am，B=b1,b2,...,bn。已经存入两个单链表中，设计一个算法，判断序列B是否是序列A的连续子序列。 

17.设计一个算法用于判断带头节点的循环双链表是否对称。 

18.有两个循环单链表，链表头指针分别为h1和h2，编写一个函数将链表h2链接到链表h1之后，要求链接后的链表仍保持循环链表形式。 

其他-王道算法题(可以运行)-链表如下

【王道数据结构与算法】- 链表算法题

1.设计一个递归算法，删除不带头节点的单链表L中所有值为x的节点。

代码实现：

//不带头结点的链表数据删除
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode;
int a[4]={1,3,3,4};
int n=4;
void buildlist(lnode *L)
{
    lnode *s,*r=L;
    r->data=a[0];
    if(n==1) r->next=NULL;
    else{
        for(int i=1;i<n;i++)
        {
            s=(lnode *)malloc(sizeof(lnode));
            s->data=a[i];
            r->next=s;
            r=r->next;
        }
        r->next=NULL;
    }
}
void disp(lnode *L)
{
    lnode *s=L;
    while(s)
    {
        cout<<(s->data)<<" ";
        s=s->next;
    }
    cout<<endl;
}
void deletex(lnode *&L,int x)
{
    if(L==NULL) return;
    lnode *p;
    if(L->data==x)
    {
        p=L;
        L=L->next;
        free(p);
        deletex(L,x);
    }
    else deletex(L->next,x);
}
int main()
{
    lnode list;
    lnode *L=&list;
    buildlist(L);
    disp(L);
    deletex(L,3);//删除所有值为3的元素
    disp(L);
    return 0;
}

2.在带头节点的单链表L中，删除所有制为x的节点，并释放其空间，假设置为x的节点不唯一，试编写算法以实现上述操作。

代码实现：

//删除带头结点的链表中的节点
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={1,3,3,4};
int n=4;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=a[i];
        r->next=s;
        r=r->next;
		r->next=NULL;
    }
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
void deletex(linklist &L,int x)
{
    lnode *p=L->next,*q,*r=L;
    while(p)
    {
        if(p->data!=x)
        {
            r->next=p;
            r=p;
            p=p->next;
        }
        else
        {
            q=p;
            p=p->next;
            free(q);
        }
    }
}
int main()
{
    linklist L;
    buildlist(L);
    disp(L);
    deletex(L,3);//删除值为3的节点
    disp(L);
    return 0;
}

3.设L为带头节点的单链表，编写算法实现从尾到头反向输出每个节点的值。

代码实现：

//不带头结点的逆序输出
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode;
int a[4]={1,2,3,4};
int n=4;
void buildlist(lnode *L)
{
    lnode *r=L,*s;
    r->data=a[0];
    if(n==1) r->next=NULL;
    else
    {
        for(int i=1;i<n;i++)
        {
            s=(lnode *)malloc(sizeof(lnode));
            s->data=a[i];
            r->next=s;
            r=r->next;
        }
        r->next=NULL;
    }
}
void disp(lnode *L)
{
    if(L!=NULL)
    {
        disp(L->next);
        cout<<(L->data)<<" ";
    }
    else return;
}
int main()
{
    lnode list;
    lnode *L=&list;
    buildlist(L);
    disp(L);
    return 0;
}

4.试编写在带头节点的单链表L这删除一个最小值节点的高效算法(假设最小值节点是唯一的)。

代码实现：

//带头结点的链表删除最小元素（唯一）
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={23,12,5,34};
int n=4;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;;
}
void deletemin(linklist &L)
{
    lnode *p=L->next,*q,*r=L,*s;
    q=p,s=r;
    while(p)
    {
        if(p->data<q->data)
        {
            q=p;
            s=r;
        }
        r=p;
        p=p->next;
    }
    s->next=q->next;
    free(q);
}
int main()
{
    linklist L;
    buildlist(L);
    disp(L);
    deletemin(L);
    disp(L);
    return 0;
}

5.试着编写算法将带头节点的单链表就地逆置，所谓“就地”就是辅助空间复杂度为O(1)。

代码实现：

//头插法逆置链表
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={1,2,3,4};
int n=4;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
void reverse(linklist &L)
{
    lnode *p=L->next,*r;
    L->next=NULL;
    while(p)
    {
        r=p->next;
        p->next=L->next;
        L->next=p;
        p=r;
    }
}
int main()
{
    linklist L;
    buildlist(L);
    cout<<"逆置之前"<<endl;
    disp(L);
    cout<<"逆置之后"<<endl;
    reverse(L);
    disp(L);
    return 0;
}

6.有一个带头节点的单链表L，设计一个算法使其元素递增有序。

//链表的直接插入排序
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={3,7,4,9};
int n=4;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
void sortlist(linklist &L)
{
    lnode *p=L->next,*r=p->next,*f;
    p->next=NULL;
    p=r;
    while(p)
    {
        r=p->next;
        f=L;
        while(f->next!=NULL&&f->next->data<p->data) f=f->next;
        p->next=f->next;
        f->next=p;
        p=r;
    }
}
int main()
{
    linklist L;
    buildlist(L);
    disp(L);
    sortlist(L);
    disp(L);
    return 0;
}

7.设在一个带表头节点的单链表中所有元素节点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值(作为函数参数给出)之间的元素的元素(若存在)。

代码实现：

//删除链表区间内的结点
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[5]={1,5,3,4,2};
int n=5;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
void deletelist(linklist &L,int min,int max)
{
    lnode *p=L->next,*r=L;
    while(p)
    {
        if(p->data<max&&p->data>min)
        {
            r->next=p->next;
            free(p);
            p=r->next;
        }
        else
        {
            r=p;
            p=p->next;
        }
    }
}
int main()
{
    linklist L;
    buildlist(L);
    disp(L);
    deletelist(L,1,4);//删除1-4之间元素
    disp(L);
    return 0;
}

8.给定两个单链表，编写算法找出两个链表的公共节点。

代码实现：

//找公共结点
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[5]={2,4,3,7,8};
int b[4]={1,3,7,8};
int n1=5,n2=4;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
int length(linklist L)
{
    int k=0;
    lnode *s=L->next;
    while(s)
    {
        k++;
        s=s->next;
    }
    return k;
}
linklist findd(linklist L1,linklist L2)
{
    int len1=length(L1),len2=length(L2);
    int dist=0;
    linklist long1,short1;
    if(len1>len2)
    {
        long1=L1->next;
        short1=L2->next;
        dist=len1-len2;
    }
    else
    {
        long1=L2->next;
        short1=L1->next;
        dist=len2-len1;
    }
    while(dist--) long1=long1->next;
    while(long1)
    {
        if(long1->data==short1->data&&long1->next->data==short1->next->data) return long1;
        else
        {
            long1=long1->next;
            short1=short1->next;   
        }
    }
    return NULL;
}
linklist findd2(linklist L1,linklist L2)
{
    lnode *s1=L1->next;
    while(s1)
    {
        lnode *s2=L2->next;
        while(s2)
        {
            if(s1->data==s2->data&&s1->next->data==s2->next->data)
            return s1;
            else s2=s2->next;
        }
        s1=s1->next;
    }
    return NULL;
}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    linklist L3=findd2(L1,L2);
    cout<<L3->data<<" "<<endl;
    return 0;
}

9.给定一个带表头节点的单链表，设head为头指针，节点结构为(data , next)，data为整型元素，next为指针，试着写出算法：按递增次序输出单链表中各个节点的数据元素，并且释放节点所占的存储空间(要求：不允许使用数组作为辅助空间)。

代码实现：

//每次删除最小值且输出
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[5]={2,5,3,8,1};
int n=5;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void deletemin(linklist &L)
{
    while(L->next!=NULL)
    {
        lnode *r=L,*p=r->next;
        while(p->next!=NULL)
        {
            if(p->next->data<r->next->data)
                r=p;
            p=p->next;
        }
        cout<<(r->next->data)<<" ";
        lnode *q=r->next;
        r->next=q->next;
        free(q);
    }
    free(L);
}
int main()
{
    linklist L;
    buildlist(L);
    deletemin(L);
    return 0;
}

10.将一个带头节点的单链表A分解为两个带头节点的单链表A和B，使得A表中含有原表中序号为奇数的元素，而B表中含有原表中序号为偶数的元素，且保持其相对顺序不变。

代码实现：

//分链表
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[5]={2,7,4,1,9};
int n=5;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
linklist L2;
void cut(linklist &L1)
{
    L2=(linklist)malloc(sizeof(lnode));
    L2->next=NULL;
    lnode *r1=L1,*r2=L2,*p=L1->next;
    int i=0;
    L1->next=NULL;
    while(p)
    {
        i++;
        if(i%2==0)
        {
            r2->next=p;
            r2=p;
        }
        else
        {
            r1->next=p;
            r1=p;
        }
        p=p->next;
    }
    r1->next=NULL;
    r2->next=NULL;
}
int main()
{
    linklist L1;
    buildlist(L1);
    cout<<"之前"<<endl;
    disp(L1);
    cut(L1);
    cout<<"L1: "<<endl;
    disp(L1);
    cout<<"L2"<<endl;
    disp(L2);
    return 0;
}

 

11.设C={a1,b1,a2,b2,...,an,bn}为线性表，采用带头节点的hc单链表存放，设计一个就地算法，将其拆分为两个线性表，使得A={a1,a2,...,an}，B={bn,...,b2,b1}。 

代码实现：

//链表拆分 头插法
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[10]={1,2,3,4,5,6,7,8,9,10};
int n=10;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
linklist L2;
void cutlist(linklist &L1)
{
    L2=(linklist)malloc(sizeof(lnode));
    L2->next=NULL;
    lnode *p=L1->next,*q,*r=L1;
    while(p)
    {
        r->next=p;
        r=p;
        p=p->next;
        if(p!=NULL) q=p->next;
        p->next=L2->next;
        L2->next=p;
        p=q;
    }
    r->next=NULL;
}
int main()
{
    linklist L1;
    buildlist(L1);
    cout<<"一开始L1"<<endl;
    disp(L1);
    cutlist(L1);
    cout<<"之后L1"<<endl;
    disp(L1);
    cout<<"之后L2"<<endl;
    disp(L2);
    return 0;
}

 

12.在一个递增有序的线性表中，有数值相同的元素存在。若存储方式为单链表，设计算法去掉数值相同的元素，使得表中不再有重复的元素，例如{7,10,10,21,30,42,42,42,51,70}将其变为{7,10,21,30,42,51,70}。 

代码实现：

//链表的重复元素删除
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[10]={7,10,10,21,30,42,42,42,51,70};
int n=10;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=a[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
void deletelist(linklist &L)
{
    if(L->next==NULL) return;
    lnode *p=L->next,*q;
    while(p->next!=NULL)
    {
        q=p->next;
        if(p->data==q->data)
        {
            p->next=q->next;
            free(q);
        }
        else p=p->next;
    }
}
int main()
{   
    linklist L;
    buildlist(L);
    cout<<"删除之前"<<endl;
    disp(L);
    deletelist(L);
    cout<<"删除之后"<<endl;
    disp(L);
    return 0;
}

 

13假设有两个按元素值递增次序排列的线性表，均以单链表形式存储，请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原来的两个单链表的节点存放归并后的单链表。 

代码实现：

//合并链表 递减
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={1,2,3,4};
int b[5]={3,4,5,6,7};
int n1=4,n2=5;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *r=L,*s;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
void merge(linklist &L1,linklist &L2)
{
    lnode *p1=L1->next,*p2=L2->next,*r;
    L1->next=NULL;
    while(p1&&p2)
    {
        if(p1->data<=p2->data)
        {
            r=p1->next;
            p1->next=L1->next;
            L1->next=p1;
            p1=r;
        }
        else
        {
            r=p2->next;
            p2->next=L1->next;
            L1->next=p2;
            p2=r;
        }
    }
    if(p1) p2=p1;
    while(p2)
    {
        r=p2->next;
        p2->next=L1->next;
        L1->next=p2;
        p2=r;
    }
    free(L2);
}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    cout<<"L1:"<<endl;
    disp(L1);
    cout<<"L2:"<<endl;
    disp(L2);
    merge(L1,L2);
    cout<<"合并之后"<<endl;
    disp(L1);
    return 0;
}

 

14.设A和B是两个单链表(带头节点)，其中元素递增有序。设计一个算法从A和B中的公共元素产生单链表C，要求不破坏A,B的节点。 

代码实现：

//找共同元素 建立新链表
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={2,3,4,9};
int n1=4;
int b[5]={4,7,9,10,11};
int n2=5;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
linklist L3;
void buildnew(linklist L1,linklist L2)
{
    L3=(linklist)malloc(sizeof(lnode));
    lnode *p1=L1->next,*p2=L2->next,*s,*r;
    r=L3;
    while(p1&&p2)
    {
        if(p1->data<p2->data) p1=p1->next;
        else if(p1->data>p2->data) p2=p2->next;
        else
        {
            s=(lnode *)malloc(sizeof(lnode));
            s->data=p1->data;
            r->next=s;
            r=s;
            p1=p1->next;
            p2=p2->next;
        }
    }
    r->next=NULL;

}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    cout<<"L1:"<<endl;
    disp(L1);
    cout<<"L2:"<<endl;
    disp(L2);
    buildnew(L1,L2);
    cout<<"L3:"<<endl;
    disp(L3);
    return 0;
}

 

15.已知两个链表A和B分别表示两个集合，其元素递增排列。编制函数，求A与B的交集，并存放于A链表中。 

代码实现：

//保留公共节点 其余删除
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={1,2,3,4};
int b[6]={2,4,5,6,7,8};
int n1=4,n2=6;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
void deletelist(linklist &L1,linklist &L2)
{
    lnode *p1=L1->next,*p2=L2->next,*r=L1,*q;
    while(p1&&p2)
    {
        if(p1->data<p2->data)
        {
            q=p1;
            p1=p1->next;
            free(q);
        }
        else if(p1->data>p2->data)
        {
            q=p2;
            p2=p2->next;
            free(q);
        }
        else
        {
            r->next=p1;
            r=p1;
            p1=p1->next;
            q=p2;
            p2=p2->next;
            free(q);
        }
    }
    while(p1)
    {
        q=p1;
        p1=p1->next;
        free(q);
    }
    while(p2)
    {
        q=p2;
        p2=p2->next;
        free(q);
    }
    r->next=NULL;
}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    cout<<"L1"<<endl;
    disp(L1);
    cout<<"L2"<<endl;
    disp(L2);
    deletelist(L1,L2);
    cout<<"L1"<<endl;
    disp(L1);
    return 0;
}

 

16.两个整数序列A=a1,a2,...,am，B=b1,b2,...,bn。已经存入两个单链表中，设计一个算法，判断序列B是否是序列A的连续子序列。 

代码实现：

//判断是否是连续子序列
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[6]={1,2,3,4,5,6};
int b[3]={3,4,5};
int n1=6,n2=3;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=NULL;
}
bool isok(linklist L1,linklist L2)
{
    lnode *p1=L1->next,*p2=L2->next,*r=L1->next;
    while(p1&&p2)
    {
        if(p1->data!=p2->data)
        {
            r=r->next;
            p1=r;
            p2=L2->next;
        }
        else
        {
            p1=p1->next;
            p2=p2->next;
        }
    }
    if(p2) return false;
    else return true;
}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    if(isok(L1,L2)) cout<<"yes"<<endl;
    else cout<<"no"<<endl;
    return 0;
}

 

若 3 ， 4 ，7则不是

 

17.设计一个算法用于判断带头节点的循环双链表是否对称。
 

代码实现：

//判断循环双链表是否是对称的
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next,*prior;
}lnode,*linklist;
int a[6]={1,2,3,3,2,1};
int n=6;
void buildlist(linklist &L)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    L->prior=L;
    L->next=L;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=a[i];
        s->next=r->next;
        r->next->prior=s;
        s->prior=r;
        r->next=s;
        r=s;
        L->prior=s;
    }
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s!=L)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
bool isok(linklist L)
{
    lnode *p=L->next,*q=L->prior;
    while(p!=q&&q->next!=p)
    {
        if(p->data==q->data)
        {
            p=p->next;
            q=q->prior;
        }
        else return false;
    }
    return true;
}
int main()
{
    linklist L;
    buildlist(L);
    disp(L);
    if(isok(L))cout<<"yes"<<endl;
    else cout<<"no"<<endl;
    return 0;
}

 

1,2,3,4,2,1很明显不对称

 

18.有两个循环单链表，链表头指针分别为h1和h2，编写一个函数将链表h2链接到链表h1之后，要求链接后的链表仍保持循环链表形式。 

代码实现：

//循环单链表的拼接
#include<iostream>
using namespace std;
typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*linklist;
int a[4]={1,2,3,4};
int b[5]={5,6,7,8,9};
int n1=4,n2=4;
void buildlist(linklist &L,int aa[],int n)
{
    L=(linklist)malloc(sizeof(lnode));
    lnode *s,*r=L;
    for(int i=0;i<n;i++)
    {
        s=(lnode *)malloc(sizeof(lnode));
        s->data=aa[i];
        r->next=s;
        r=r->next;
    }
    r->next=L;
}
void disp(linklist L)
{
    lnode *s=L->next;
    while(s!=L)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<endl;
}
void add(linklist &L1,linklist &L2)
{
    lnode *p=L1->next,*q=L2->next;
    while(p->next!=L1)
    {
        p=p->next;
    }
    while(q->next!=L2){
        q=q->next;
    }
    p->next=L2->next;
    q->next=L1;
}
int main()
{
    linklist L1,L2;
    buildlist(L1,a,n1);
    buildlist(L2,b,n2);
    cout<<"L1"<<endl;
    disp(L1);
    cout<<"L2"<<endl;
    disp(L2);
    add(L1,L2);
    cout<<"L1"<<endl;
    disp(L1);
    return 0;
}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

chenruhan_QAQ_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值