线性表的基本操作及应用（链表）

题目一：单链表的基本操作（*）
[问题描述]
实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求]
（1）依次从键盘读入数据，建立带头结点的单链表；
（2）输出单链表中的数据元素
（3）求单链表的长度；
（4）根据指定条件能够取元素和修改元素；
（5）实现在指定位置插入和删除元素的功能。
[测试数据]
由学生任意指定。
CODE：

#include <iostream>
#include <cstdio>
#include <malloc.h>
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
} LNode,*LinkList;
void CreateList(LinkList &L,int len)
{
    int i,n;
    LNode *p,*s;
    p=(LinkList)malloc(sizeof(LNode));
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    p=L;
    printf("输入链表元素:\n");
    for(i=1; i<=len; i++)
    {
        s=(LinkList)malloc(sizeof(LNode));
        cin>>n;
        s->data=n;
        s->next=NULL;
        p->next=s;
        p=p->next;
    }
}
int Getlen(LinkList L)
{
    L=L->next;
    int sum=0;
    while(L)
    {
        sum++;
        L=L->next;
    }
    return sum;
}
void GetLinkList(LinkList &L)
{
    printf("输入元素位置：");
    int x;
    cin>>x;
    LNode *p;
    p=(LinkList)malloc(sizeof(LNode));
    p=L;
    int sum=0;
    while(p&&sum!=x)
    {
        sum++;
        p=p->next;
    }

    if(!p)
        cout<<"输入位置错误！"<<endl;
    else
        cout<<p->data<<endl;
}
void Change(LinkList &L)
{
    printf("输入元素位置及元素数据：\n");
    int x,n;
    cin>>x>>n;
    LNode *p;
    p=(LinkList)malloc(sizeof(LNode));
    p=L;
    int sum=0;
    while(p&&sum!=x)
    {
        sum++;
        p=p->next;
    }
    if(!p)
        cout<<"输入位置错误！"<<endl;
    else
    {
        cout<<"修改成功！"<<endl;
        p->data=n;
    }
}
void Insert(LinkList &L)
{
    printf("输入插入元素位置及元素数据：\n");
    int x,n;
    cin>>x>>n;
    LNode *p;
    p=(LinkList)malloc(sizeof(LNode));
    p=L;
    int sum=1;
    LNode *s;
    s=(LinkList)malloc(sizeof(LNode));
    while(p&&sum!=x)
    {
        sum++;
        p=p->next;
    }
    if(!p)
        cout<<"输入位置错误！"<<endl;
    else
    {
        cout<<"插入成功！"<<endl;
        if(p->next)
        {
            s->data=n;
            s->next=p->next;
            p->next=s;
        }
        else
        {
            s->data=n;
            s->next=NULL;
            p->next=s;
        }
    }
}
void Delete(LinkList &L)
{
    printf("输入删除元素位置：\n");
    int x;
    cin>>x;
    LNode *p;
    p=(LinkList)malloc(sizeof(LNode));
    p=L;
    LNode *s;
    s=(LinkList)malloc(sizeof(LNode));
    int sum=1;
    while(p&&sum!=x)
    {
        sum++;
        p=p->next;
    }
    if(!p)
        cout<<"输入位置错误！"<<endl;
    else
    {
        cout<<"删除成功！"<<endl;
        s=p->next;
        if(p->next->next)
            p->next=p->next->next;
        else
            p->next=NULL;
        delete(s);
    }
}
void List(LinkList L)
{
    LNode *p;
    p=(LinkList)malloc(sizeof(LNode));
    p=L->next;
    while(p)
    {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
int main()
{
    int len;
    printf("输入链表长度：");
    cin>>len;
    LinkList L;
    CreateList(L,len);
    printf("0.退出\n1.求长度\n2.取元素\n3.修改元素\n4.插入\n5.删除\n6.列出全部元素\n");
    while(true)
    {
        int n;
        bool flag=false;
        cin>>n;
        switch(n)
        {
        case 0:
            flag=true;
            break;
        case 1:
            cout<<"长度:"<<Getlen(L)<<endl;
            break;
        case 2:
            GetLinkList(L);
            break;
        case 3:
            Change(L);
            break;
        case 4:
            Insert(L);
            break;
        case 5:
            Delete(L);
            break;
        case 6:
            List(L);
            break;
        }
        if(flag)
            break;
    }
    return 0;
}

题目二：约瑟夫环（**）
[问题描述]
　　约瑟夫（Joseph）问题的一种描述是：编号为1,2,…,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序。
[基本要求]
　　利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。
[测试数据]
由学生任意指定。
　　如：m的初值为20；n的值为7；密码：3，1，7，2，4，8，4；
（正确的输出结果应为6，1，4，7，2，3，5）。
(报告上要求写出多批数据测试结果)

输入：

20 7
3 1 7 2 4 8 4

输出：

6 1 4 7 2 3 5

[实现提示]
　　程序运行后首先要求用户输入初始报数上限值m，人数n,(设n≤30)。然后输入各人的密码。
[选作内容]
　　向上述程序中添加在顺序结构上实现的部分。

CODE:

#include <iostream>
#include <malloc.h>
using namespace std;
typedef struct LNode
{
    int num,data;
    struct LNode *next;
} LNode,*LinkList;
void CreateList(LinkList &L,int len)
{
    int i,m;
    LNode *p;
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    p=L;
    for(i=1; i<=len; i++)
    {
        LNode *s;
        s=(LinkList)malloc(sizeof(LNode));
        cin>>m;
        s->data=m;
        s->num=i;
        s->next=NULL;
        p->next=s;
        p=p->next;
    }
    p->next=L->next;
    L=L->next;
}
void traver(LinkList &L,int m,int len)
{
    int sum=1;
    LNode *s;
        s=(LinkList)malloc(sizeof(LNode));
    while(len!=0)
    {
        if(sum==m)
        {
            LNode *p;
            p=(LinkList)malloc(sizeof(LNode));
            p=L;
            cout<<L->num<<" ";
            m=L->data;
            L=L->next;
            s->next=L;
            sum=1;len--;
            delete(p);
            continue;
        }
        s=L;
        L=L->next;
        sum++;
    }
}
int main()
{
    int m,n;
    while(cin>>m>>n)
    {
        LinkList L;
        CreateList(L,n);
        traver(L,m,n);
        cout<<endl;
    }
    return 0;
}

题目三：多项式的表示及相加（***）
[问题描述]
设计一个算法，以实现一元稀疏多项式的加法运算。
[基本要求]
（1）输入并建立多项式；
（2）输出多项式，输出形式为整数序列：n，c1，e1，c2，e2，……，cn，en，其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；
（3）多项式a和b相加，建立多项式a+b。
[测试数据]
由学生任意指定。
[实现提示]
　　用带表头结点的单链表存储多项式。
[选作内容]
　　多项式a和b相减，建立多项式a-b。
输入：

5
1 7
2 5
3 4
4 2
5 1
1 9
2 5
3 4
4 3
5 2

输出：

1X9+1X7+4X5+6X4+4X3+9X2+5X1

CODE:

#include <iostream>
#include <malloc.h>
using namespace std;
typedef struct pol
{
    int c,e;
    struct pol *next;
} pol,*Linkpol;
void Createpol(Linkpol &L)
{
    L=(Linkpol)malloc(sizeof(pol));
    L->next=NULL;
}
void inpol(Linkpol &L,int n)
{
    int i,x,y;
    pol *p;
    p=(Linkpol)malloc(sizeof(pol));
    p=L;
    for(i=0; i<n; i++)
    {
        pol *s;
        s=(Linkpol)malloc(sizeof(pol));
        cin>>x>>y;
        s->c=x;
        s->e=y;
        s->next=NULL;
        p->next=s;
        p=s;
    }
}
void add(Linkpol &La,Linkpol &Lb)
{
    pol *p;
    p=(Linkpol)malloc(sizeof(pol));
    p=La;
    pol *s;
    while(p->next&&Lb->next)
    {
        if((p->next->e)==(Lb->next->e))
        {
            p->next->c=p->next->c+Lb->next->c;
            p=p->next;
            Lb=Lb->next;
        }
        else if((p->next->e)<(Lb->next->e))
        {
            s=(Linkpol)malloc(sizeof(pol));
            s->c=Lb->next->c;
            s->e=Lb->next->e;
            s->next=p->next;
            p->next=s;
            Lb=Lb->next;
            p=p->next;
        }
        else
        {
            p=p->next;
        }
    }
    if(Lb->next)
        p->next=Lb->next;
}
void out(Linkpol La)
{
    int i=1;
    La=La->next;
    cout<<La->c<<"X"<<La->e;
    while(La->next)
    {
        La=La->next;
        cout<<"+"<<La->c<<"X"<<La->e;
        i++;
    }
}
int main()
{
    int n;
    cin>>n;
    Linkpol La,Lb;
    Createpol(La);
    inpol(La,n);
    Createpol(Lb);
    inpol(Lb,n);
    add(La,Lb);
    out(La);
    return 0;
}

题目四：Dr.Kong设计了一件艺术品（****）
[问题描述]
Dr.Kong设计了一件艺术品，该艺术品由N个构件堆叠而成，N个构件从高到低按层编号依次为1，2，……,N。艺术品展出后，引起了强烈的反映。Dr.Kong观察到，人们尤其对作品的高端部分评价甚多。
狂热的Dr.Kong一激动，对组成该艺术品的N个构件重新组合，比如：把第6层到第12层的构件搬下来，想一想，然后整体放到剩下构件的第7层下面；过一会儿，又把第2层到第9层的构件搬下来，整体放到剩下构件的第1层下面等等。于是，Dr.Kong在进行了连续若干次“搬来搬去”后，还是这N个构件，又诞生了一件新的艺术品。
编程：请输出新的艺术品最高十层构件的编号。

【标准输入】
第一行: N K 表示构件的总数和“搬来搬去”的总次数
第2~K+1行：A B C 表示要搬动的构件（即从第A层到第B层）整个放在第C层下面；
如果C等于0，则要搬动的构件将放到最高层。
【标准输出】
由十行组成，分别为组成新艺术品的第一层到第十层构件的编号。
【约束条件】
（1） 10≤N≤20000 1≤k≤1000
（2） 1≤A≤B≤N， 0≤C≤N-(B-A+1)
【 样 例 】
提示：样例中仅是常规的测试数据输入及对应结果，特殊情况需要全面考虑，自己设计测试数据验证算法的健壮性。
标准输入（测试数据）：

扫描二维码关注公众号，回复： 11473867 查看本文章

13 3
6 12 1
2 9 0
10 13 8

标准输出结果：

6
7
8
9
10
11
12
2
3
4

[实现提示]
　　适宜于用带表头结点的单链表实现，涉及单个结点或连续多个结点的插入与删除。
[选作内容]
　　分别用不带头结点的单链表和顺序表实现，领会三种方法的算法设计的优缺点和时间复杂度。
CODE:

#include <iostream>
#include <malloc.h>
using namespace std;
typedef struct art
{
    int num;
    struct art *next;
} art,*Linkart;
void outart(Linkart L);
void creatart(Linkart &L)
{
    L=(Linkart)malloc(sizeof(art));
    L->next=NULL;
}
void inart(Linkart &L,int n)
{
    int i;
    art *p;
    p=(Linkart)malloc(sizeof(art));
    p=L;
    for(i=1; i<=n; i++)
    {
        art *s;
        s=(Linkart)malloc(sizeof(art));
        s->num=i;
        s->next=NULL;
        p->next=s;
        p=s;
    }
}
void swapart(Linkart &L,int m)
{
    int a,e,x;
    while(m--)
    {
        cin>>a>>e>>x;
        int sa,se,sx;
        sa=se=sx=0;
        art *p;
        p=(Linkart)malloc(sizeof(art));
        p=L;
        while(sx!=x&&p)
        {
            sx++;
            p=p->next;
        }
        art *s;
        s=(Linkart)malloc(sizeof(art));
        s=L;
        while((sa+1)!=a&&s)
        {
            sa++;
            s=s->next;
        }
        art *s1;
        s1=(Linkart)malloc(sizeof(art));
        s1=s->next;
        art *q;
        q=(Linkart)malloc(sizeof(art));
        q=s;
        while(sa!=e&&q)
        {
            sa++;
            q=q->next;
        }
        if(q->next)
            s->next=q->next;
        else
            s->next=NULL;
        q->next=p->next;
        p->next=s1;
    }
}
void outart(Linkart L)
{
    int sum=0;
    L=L->next;
    while(sum!=10&&L)
    {
        cout<<L->num<<endl;
        L=L->next;
        sum++;
    }
}
int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        Linkart L;
        creatart(L);
        inart(L,n);
        swapart(L,m);
        outart(L);
    }
    return 0;
}