《程序设计基础II》实验2——链表

已于 2022-03-16 15:58:09 修改
阅读量1.6k 收藏 9
点赞数 2
文章标签： 链表 数据结构 散列表
于 2022-02-26 23:18:38 首次发布
简 阳
本文链接：https://blog.csdn.net/qq_62268699/article/details/123157806
版权

A - 数据结构实验之链表一：顺序建立链表

Description

输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。

Input

第一行输入整数的个数N；
第二行依次输入每个整数。

Output

输出这组整数。

Sample

Input

8
12 56 4 6 55 15 33 62

Output

12 56 4 6 55 15 33 62

Hint

不得使用数组！

#include <stdio.h>
#include <stdlib.h>
struct node{
int data;
struct node *next;
};
int main()
{int n;
int i;
scanf("%d",&n);
struct node *head=(struct node *)malloc(sizeof(struct node));
head->next=NULL;
struct node *p=head;
for(i=1;i<=n;i++){
    int x;
    scanf("%d",&x);
    struct node *q=(struct node *)malloc(sizeof(struct node));
    q->data=x;
   q->next=NULL;
   p->next=q;
  p=q;
    }

    p=head->next;
   while(p){
    if(p->next)
        printf("%d ",p->data);
    else printf("%d\n",p->data);
    p=p->next;
}
    return 0;
}

B - 数据结构实验之链表二：逆序建立链表

Description

输入整数个数N，再输入N个整数，按照这些整数输入的相反顺序建立单链表，并依次遍历输出单链表的数据。

Input

第一行输入整数N;；
第二行依次输入N个整数，逆序建立单链表。

Output

依次输出单链表所存放的数据。

Sample

Input 

10
11 3 5 27 9 12 43 16 84 22

Output 

22 84 16 43 12 9 27 5 3 11

Hint

不能使用数组！

#include <stdio.h>
#include <stdlib.h>
struct node{
int data;
struct node *next;
};
int main()
{int n;
int i;
scanf("%d",&n);
struct node *head=(struct node *)malloc(sizeof(struct node));
head->next=NULL;
for(i=1;i<=n;i++){
    int x;
    scanf("%d",&x);
    struct node *q=(struct node *)malloc(sizeof(struct node));
    q->data=x;
    q->next=head->next;
    head->next=q;}
    struct node *p;
    p=head->next;
 while(p){
    if(p->next)
        printf("%d ",p->data);
    else printf("%d\n",p->data);
    p=p->next;
}
    return 0;
}

C - 师--链表的结点插入

Description

给出一个只有头指针的链表和 n 次操作，每次操作为在链表的第 m 个元素后面插入一个新元素x。若m 大于链表的元素总数则将x放在链表的最后。

Input

多组输入。每组数据首先输入一个整数n(n∈[1,100])，代表有n次操作。

接下来的n行，每行有两个整数Mi(Mi∈[0,10000])，Xi。

Output

对于每组数据。从前到后输出链表的所有元素,两个元素之间用空格隔开。

Sample

Input 

4
1 1
1 2
0 3
100 4

Output 

3 1 2 4

Hint

样例中第一次操作1 1，由于此时链表中没有元素，1>0,所以此时将第一个数据插入到链表的最后，也就是头指针的后面。

#include <stdio.h>
#include <stdlib.h>
struct node{
int data;
struct node*next;
};
int main(){
    int n,i;
while(~scanf("%d",&n))
{struct node *head=(struct node*)malloc(sizeof(struct node));
head->next=NULL;
for(i=1;i<=n;i++){
        int mi,x;
scanf("%d%d",&mi,&x);
    struct node*p=head;
    while(p->next&&mi--){
        p=p->next;
    }
    struct node*q=(struct node *)malloc(sizeof(struct node));
    q->data=x;
    q->next=p->next;
    p->next=q;

}
struct node *p=head->next;
while(p){
    if(p->next)
        printf("%d ",p->data);
    else printf("%d\n",p->data);
    p=p->next;
}
}

return 0;
}

D - 数据结构实验之链表七：单链表中重复元素的删除

Description

按照数据输入的相反顺序（逆位序）建立一个单链表，并将单链表中重复的元素删除（值相同的元素只保留最后输入的一个）。

Input

第一行输入元素个数 n (1 <= n <= 15)；
第二行输入 n 个整数，保证在 int 范围内。

Output

第一行输出初始链表元素个数；
第二行输出按照逆位序所建立的初始链表；
第三行输出删除重复元素后的单链表元素个数；
第四行输出删除重复元素后的单链表。

Sample

Input 

10
21 30 14 55 32 63 11 30 55 30

Output 

10
30 55 30 11 63 32 55 14 30 21
7
30 55 11 63 32 14 21
#include <stdio.h>
#include <stdlib.h>
struct node
{
    int data;
    struct node *next;
};
int main()
{
    int n,x,i;
    scanf("%d",&n);
    struct node*head=(struct node *)malloc(sizeof(struct node));
    head->next=NULL;
    for(i=1; i<=n; i++)
    {
        scanf("%d",&x);
        struct node *p=(struct node *)malloc(sizeof(struct node));
        p->data=x;
        p->next=head->next;
        head->next=p;
    }
    printf("%d\n",n);
    struct node *p=head->next;
    while(p)
    {
        if(p->next)
        {
            printf("%d ",p->data);
        }
        else printf("%d\n",p->data);
        p=p->next;
    }
    int t=0;
    struct node *q=head;
    while(q->next)
    {
        struct node *p=q->next;
        while(p->next)
        {
            if(p->next->data==q->next->data)
            {
                p->next=p->next->next;
                t++;
            }
            else p=p->next;
        }
        q=q->next;
    }
    printf("%d\n",n-t);
    p=head->next;
    while(p)
    {
        if(p->next)
        {
            printf("%d ",p->data);
        }
        else printf("%d\n",p->data);
        p=p->next;
    }

    return 0;
}

E - 数据结构实验之链表三：链表的逆置

Description

输入多个整数，以-1作为结束标志，顺序建立一个带头结点的单链表，之后对该单链表的数据进行逆置，并输出逆置后的单链表数据。

Input

输入多个整数，以-1作为结束标志。

Output

输出逆置后的单链表数据。

Sample

Input 

12 56 4 6 55 15 33 62 -1

Output 

62 33 15 55 6 4 56 12

Hint

不得使用数组。

#include <stdio.h>
#include <stdlib.h>
struct node{
int data;
struct node *next;
};
int main()
{int x;
struct node *head=(struct node *)malloc(sizeof(struct node));
head->next=NULL;
while(~scanf("%d",&x)){
    if(x==-1)
    break;
    struct node *q=(struct node *)malloc(sizeof(struct node));
    q->data=x;
    q->next=head->next;
    head->next=q;}
    struct node *p;
    p=head->next;
  while(p){
    if(p->next)
        printf("%d ",p->data);
    else printf("%d\n",p->data);
    p=p->next;
}
    return 0;
}

F - 数据结构实验之链表四：有序链表的归并

Description

分别输入两个有序的整数序列（分别包含M和N个数据），建立两个有序的单链表，将这两个有序单链表合并成为一个大的有序单链表，并依次输出合并后的单链表数据。

Input

第一行输入M与N的值；
第二行依次输入M个有序的整数；
第三行依次输入N个有序的整数。

Output

输出合并后的单链表所包含的M+N个有序的整数。

Sample

Input 

6 5
1 23 26 45 66 99
14 21 28 50 100

Output 

1 14 21 23 26 28 45 50 66 99 100

Hint

不得使用数组！

#include <stdio.h>
#include <stdlib.h>
struct node
{
    int data;
    struct node *next;
};
int main()
{
    int m,n,i,x;
    scanf("%d%d",&m,&n);
    struct node *head1,*head2,*head3,*p,*q,*r;
    head1=(struct node *)malloc(sizeof(struct node));
    head1->next=NULL;
    q=head1;
    for(i=1; i<=m; i++)
    {
        scanf("%d",&x);
        struct node *p=(struct node *)malloc(sizeof(struct node));
        p->data=x;
        p->next=NULL;
        q->next=p;
        q=p;
    }
    head2=(struct node *)malloc(sizeof(struct node ));
    head2->next=NULL;
    q=head2;
    for(i=1; i<=n; i++)
    {
        scanf("%d",&x);
        struct node *p=(struct node *)malloc(sizeof(struct node));
        p->data=x;
        p->next=NULL;
        q->next=p;
        q=p;
    }
    head3=(struct node *)malloc(sizeof(struct node));
    head3->next=NULL;
    p=head1->next;
    q=head2->next;
    r=head3;
    for(i=1; i<=m+n; i++)
    {
        if(q&&p)
        {
            if(p->data>q->data)
            {
                r->next=q;
                r=q;
                q=q->next;
            }
            else
            {
                r->next=p;
                r=p;
                p=p->next;

            }

        }
        else
        {
            if(p)
            {
                r->next=p;
            }
            if(q)
            {
                r->next=q;
            }
        }
    }
    q=head3->next;
    while(q)
    {
        if(q->next)
            printf("%d ",q->data);
        else printf("%d\n",q->data);
        q=q->next;
    }

    return 0;
}

G - 数据结构实验之链表五：单链表的拆分

Description

输入N个整数顺序建立一个单链表，将该单链表拆分成两个子链表，第一个子链表存放了所有的偶数，第二个子链表存放了所有的奇数。两个子链表中数据的相对次序与原链表一致。

Input

第一行输入整数N;；
第二行依次输入N个整数。

Output

第一行分别输出偶数链表与奇数链表的元素个数；
第二行依次输出偶数子链表的所有数据；
第三行依次输出奇数子链表的所有数据。

Sample

Input 

10
1 3 22 8 15 999 9 44 6 1001

Output 

4 6
22 8 44 6 
1 3 15 999 9 1001

Hint

不得使用数组！

#include <stdio.h>
#include <stdlib.h>
struct node{
int data;
struct node *next;
};
void show(struct node *head){
struct node *p;
p=head->next;
while(p){
    if(p->next)
        printf("%d ",p->data);
    else printf("%d\n",p->data);
    p=p->next;
}
}
int main()
{int n;
scanf("%d",&n);
int i,m=0,h=0;
struct node *head1=(struct node *)malloc(sizeof(struct node));
struct node *head2=(struct node *)malloc(sizeof(struct node));
head1->next=NULL;
head2->next=NULL;
struct node *t=head1;
struct node *q=head2;
for(i=1;i<=n;i++){
    struct node *p=(struct node *)malloc(sizeof(struct node));
    int x;
    scanf("%d",&x);
    p->data=x;
    if(p->data%2==0){
        p->next=NULL;
        t->next=p;
        t=t->next;
        m++;
    }else{
    p->next=NULL;
    q->next=p;
    q=q->next;
    h++;
    }
}
printf("%d %d\n",m,h);
show(head1);
show(head2);

      return 0;
}

H - 数据结构实验之链表九：双向链表

Description

学会了单向链表，我们又多了一种解决问题的能力，单链表利用一个指针就能在内存中找到下一个位置，这是一个不会轻易断裂的链。但单链表有一个弱点——不能回指。比如在链表中有两个节点A,B，他们的关系是B是A的后继，A指向了B，便能轻易经A找到B,但从B却不能找到A。一个简单的想法便能轻易解决这个问题——建立双向链表。在双向链表中，A有一个指针指向了节点B，同时，B又有一个指向A的指针。这样不仅能从链表头节点的位置遍历整个链表所有节点，也能从链表尾节点开始遍历所有节点。对于给定的一列数据，按照给定的顺序建立双向链表，按照关键字找到相应节点，输出此节点的前驱节点关键字及后继节点关键字。

Input

第一行两个正整数n（代表节点个数），m（代表要找的关键字的个数）。第二行是n个数（n个数没有重复），利用这n个数建立双向链表。接下来有m个关键字，每个占一行。

Output

对给定的每个关键字，输出此关键字前驱节点关键字和后继节点关键字。如果给定的关键字没有前驱或者后继，则不输出。
注意：每个给定关键字的输出占一行。一行输出的数据之间有一个空格，行首、行末无空格。

Sample

Input 

10 3
1 2 3 4 5 6 7 8 9 0
3
5
0

Output 

2 4
4 6
9
#include <stdio.h>
#include <stdlib.h>
struct node{
int data;
struct node *next,*pre;
};
int main()
{
struct node *head=(struct node*)malloc(sizeof(struct node));
head->next=NULL;
struct node *p=head;
int x,i;
int n,m;
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++){
    scanf("%d",&x);
    struct node *q=(struct node *)malloc(sizeof(struct node));
    q->data=x;
    q->next=NULL;
    q->pre=p;
    p->next=q;
    p=q;
}
  while(m--){
    int h;
    scanf("%d",&h);
    p=head->next;
    while(p->data!=h)
        p=p->next;
        if(p->pre!=head&&p->next&&p->pre)
            printf("%d %d\n",p->pre->data,p->next->data);
        else if (p->pre&&p->pre!=head)
    printf("%d\n",p->pre->data);
    else printf("%d\n",p->next->data);
  }
    return 0;
}

I - 约瑟夫问题

Description

n个人想玩残酷的死亡游戏，游戏规则如下：

n个人进行编号，分别从1到n，排成一个圈，顺时针从1开始数到m，数到m的人被杀，剩下的人继续游戏，活到最后的一个人是胜利者。

请输出最后一个人的编号。

Input

输入n和m值。

Output

输出胜利者的编号。

Sample

Input 

5 3

Output 

4

Hint

第一轮：3被杀第二轮：1被杀第三轮：5被杀第四轮：2被杀

#include <stdio.h>
#include <stdlib.h>
struct node
{
    int data;
    struct node *next;

};
int main()
{
    int n,m,i;
    scanf("%d%d",&n,&m);
    struct node *head=(struct node *)malloc(sizeof(struct node));
    head->next=NULL;
    struct node *p=head;
    for(i=1; i<=n; i++)
    {
        struct node *q=(struct node *)malloc(sizeof(struct node));
        q->data=i;
        q->next=NULL;
        p->next=q;
        p=q;
    }
    p->next=head->next;
    p=head;
    if(m==1)
        printf("%d\n",n);
    else
    {
        while(p)
        {
            for(i=1; i<m; i++)
            {
                p=p->next;
            }
            p->next=p->next->next;
            if(p->data==p->next->data)
                break;
        }
        printf("%d\n",p->data);
    }
    return 0;
}

J - 不敢死队问题

Description

说到“敢死队”，大家不要以为我来介绍电影了，因为数据结构里真有这么道程序设计题目，原题如下：

有M个敢死队员要炸掉敌人的一个碉堡，谁都不想去，排长决定用轮回数数的办法来决定哪个战士去执行任务。如果前一个战士没完成任务，则要再派一个战士上去。现给每个战士编一个号，大家围坐成一圈，随便从某一个战士开始计数，当数到5时，对应的战士就去执行任务，且此战士不再参加下一轮计数。如果此战士没完成任务，再从下一个战士开始数数，被数到第5时，此战士接着去执行任务。以此类推，直到任务完成为止。

这题本来就叫“敢死队”。“谁都不想去”，就这一句我觉得这个问题也只能叫“不敢死队问题”。今天大家就要完成这道不敢死队问题。我们假设排长是1号，按照上面介绍，从1号开始数，数到5的那名战士去执行任务，那么排长是第几个去执行任务的？

Input

输入包括多组数据，每组一行，包含一个整数M（0<=M<=10000)（敢死队人数），若M==0，输入结束，不做处理。

Output

输出一个整数n，代表排长是第n个去执行任务。

Sample

Input 

9
6
223
0

Output 

2
6
132
#include <stdio.h>
#include <stdlib.h>
struct node
{
    int data;
    struct node *next;

};
int main()
{
    int n,i;
    while(~scanf("%d",&n))
    {if(n==0)
    break;
        struct node *head=(struct node *)malloc(sizeof(struct node));
        head->next=NULL;
        struct node *p=head;
        for(i=1; i<=n; i++)
        {
            struct node *q=(struct node *)malloc(sizeof(struct node));
            q->data=i;
            q->next=NULL;
            p->next=q;
            p=q;
        }
        p->next=head->next;
        p=head;
        int t=0;
        while(1)
            {
                for(i=1; i<5; i++)
                {
                    p=p->next;
                }
                t++;
                if(p->next->data==1)
                    break;
                    p->next=p->next->next;
            }
            printf("%d\n",t);

    }
    return 0;
}

  

简·阳
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Python编程题：输入一个整数n，再输入n个整数，按照输入的顺序建立单链表，并遍历所建立的单链表，输出这些数据。 输入格式: 测试数据有多组，处理到文件尾。每组测试输入一个整数n，再输入n个整数。 ...
weixin_42601702的博客
12-31 1807
这是一个经典的单链表的练习题。我们可以先定义一个单链表的类，并实现一些基本的方法。 代码如下： class Node: def __init__(self, data=None): self.data = data self.next = None class SingleLinkedList: def __init__(self): ...
链表-顺序建立
美杜莎的博客
04-10 389
A - 数据结构实验之链表一：顺序建立链表 Description 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 Input 第一行输入整数的个数N； 第二行依次输入每个整数。 Output 输出这组整数。 Sample Input 8 12 56 4 6 55 15 33 62 Output 12 56 4 6 55 15 33 62 Hint 不得使用数组！ #include <stdio.h> #include...
用带表头的链表存放输入的数据，每读入一个数，按升序顺序插入到链表中
12-15
用带表头的链表存放输入的数据，每读入一个数，按升序顺序插入到链表中，链表中允许两个结点有相同值。链表的头结点存放链表后面的结点个数，初始化时就生成头结点（初值为0）。链表翻转是把数据逆序（变成降序），注意，头结点不动。翻转后要再翻转一次，恢复升序后才能插入新元素，否则会出错。
复旦大学C语言程序设计解答——链表部分2
06-23
14题：集合运算。输入：两个链表，每个链表均为若干个有序正整数(单个链表中无重复数字)， 以0表示一个链表终止，第一个链表为S1，第二个链表为S2。 输出：分三行，分别输出两个集合的并集、差集（S1-S2)和交集。因 为要连续输出三个链表，无法实现原题中“将运算结果放在S1中”的要求，所以要求放宽，只需保证生成三个链表，然后依次输出即可。 不可以跳过生成链表，直接输出。另外，题目中要求链表带辅助表元，那这里就不强制要求了，自行决定。要注意两个链表中，有一个或者两个空链表的情况。
顺序建立链表
qq_45666654的博客
03-21 7761
数据结构实验之链表一：顺序建立链表 Description 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 Input 第一行输入整数的个数N； 第二行依次输入每个整数。 Output 输出这组整数。 Sample Input 8 12 56 4 6 55 15 33 62 Output 12 56 4 6 55 15 33 62 #include<stdi...
数据结构实验之链表一：顺序建立链表
weixin_34049032的博客
01-22 879
题目描述 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 输入 第一行输入整数的个数N；第二行依次输入每个整数。 输出 输出这组整数。 示例输入 8 12 56 4 6 55 15 33 62 示例输出 12 56 4 6 55 15 33 62 1 #include<stdio.h> 2 #include&...
数据结构实验之链表九：双向链表
几年的世界
02-29 401
数据结构实验之链表九：双向链表 Description 学会了单向链表，我们又多了一种解决问题的能力，单链表利用一个指针就能在内存中找到下一个位置，这是一个不会轻易断裂的链。但单链表有一个弱点——不能回指。比如在链表中有两个节点A,B，他们的关系是B是A的后继，A指向了B，便能轻易经A找到B,但从B却不能找到A。一个简单的想法便能轻易解决这个问题——建立双向链表。在双向链表中，A有一个指针指向...
JavaScript编程题，顺序遍历链表：输入一个整数n，再输入n个整数，按照输入的顺序建立单链表，并遍历所建立的单链表，输出这些数据。 输入格式: 测试数据有多组，处理到文件尾。每组测试输入一个整...
weixin_42584586的博客
01-07 162
你可以使用JavaScript的一个简单的链表类来建立一个单链表。 然后，您可以使用一个for循环来遍历每个节点，并使用console.log()函数输出数据。 例如： class LinkedList { constructor() { this.head = null; this.tail = null; } addNode(data) { const n...
复旦大学C语言程序设计解答——链表部分4
06-23
//第7题：有序链表合并。输入：两个有序正整数链表 //(保证正整数从小到大输入，但可能有重复数字，输入为0表示终止）。 //输出：合并后的链表（将链表中的数字有序输出）。 //要求：一定要用链表实现，不能单单复制...
C语言程序设计——职工管理系统（链表）.zip
07-13
C语言程序设计——职工管理系统（链表）.zip
复旦大学C语言程序设计解答——链表部分3
06-23
//第8题：复制链表。输入：一个无序正整数链表（输入为0表示终止）。 //输出：三行，每行一个链表，分别满足题目中的三个链表的要求。 //这道题目必须要复制链表，所以说，不能直接将输入的链表作为第一小题的输出，...
程序设计基础10_链表
01-28
程序设计基础10_链表（2015春）.ppt
数据结构实验之链表二：逆序建立链表
几年的世界
02-27 279
数据结构实验之链表二：逆序建立链表 Description 输入整数个数N，再输入N个整数，按照这些整数输入的相反顺序建立单链表，并依次遍历输出单链表的数据。 Input 第一行输入整数N;； 第二行依次输入N个整数，逆序建立单链表。 Output 依次输出单链表所存放的数据。 Sample Input 10 11 3 5 27 9 12 43 16 84 22 Outp...
单链表的建立和遍历
weixin_51929568的博客
10-08 1680
输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 输入格式: 输入数据有多组，每组数据占两行；每组第一行为一个数字N（0<N<=50）；第二行有N个整数。 输出格式: 每组输出占一行，输出这组整数，每两个数字之间用一个空格分隔。 输入样例: 在这里给出一组输入。例如： 5 12 32 45 78 54 结尾无空行 输出样例: 在这里给出相应的输出。例如： 12 32 45 78 54 结尾无空行 #include<stdio.h> #inc
单链表的创建及遍历
qq_53056413的博客
03-14 1962
单链表的创建及遍历
哈希表设计与实现——链表法
最新发布
05-10
为了解决这个问题，可以使用链表法。 链表法是一种解决哈希表碰撞问题的方法。具体来说，对于哈希表中的每个桶，可以使用一个链表来存储所有映射到该桶的键值对。如果发生碰撞，只需要将新的键值对添加到链表的末尾...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值