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

目录

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

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

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

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

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

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

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

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

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

---

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

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

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

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;
}