期末考试应付版（也可以说是数组模拟链表完全版）

最新推荐文章于 2024-10-07 15:21:22 发布

CRAEN

最新推荐文章于 2024-10-07 15:21:22 发布

阅读量691

点赞数 4

分类专栏： PTA 山东理工大学小白文章标签：经验分享

本文链接：https://blog.csdn.net/sky_kin/article/details/124437695

版权

山东理工大学同时被 3 个专栏收录

30 篇文章 26 订阅

订阅专栏

小白

28 篇文章 2 订阅

订阅专栏

PTA

14 篇文章 24 订阅

订阅专栏

重申一遍，我不是水文章（手动狗头）

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

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

输入格式:

第一行输入整数的个数N(1 <= N <= 100000)。

第二行依次输入每个整数。

输出格式:

输出这组整数。

样例">样例">输入样例:

8
12 56 4 6 55 15 33 62

输出样例:

12 56 4 6 55 15 33 62

#include<stdio.h>
int main()
{
	int n,i;
	scanf("%d",&n);
	int a[n];
	for(i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	for(i=0;i<n;i++)
	{
		if(i!=n-1)
		printf("%d ",a[i]);
		else printf("%d",a[i]);
	}
	return 0;
}

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

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

输入格式:

第一行输入整数N（1<=N<=100000)。

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

输出格式:

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

输入样例:

10
11 3 5 27 9 12 43 16 84 22

输出样例:

22 84 16 43 12 9 27 5 3 11

#include<stdio.h>
int main()
{
	int n,i;
	scanf("%d",&n);
	int a[n];
	for(i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	for(i=n-1;i>=0;i--)
	{
		if(i!=0)
		printf("%d ",a[i]);
		else printf("%d",a[i]);
	}
	return 0;
}

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

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

输入格式:

输入多个整数，以-1作为结束标志。（整数个数不超过100000，不低于1）

输出格式:

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

输入样例:

12 56 4 6 55 15 33 62 -1

输出样例:

62 33 15 55 6 4 56 12

#include<stdio.h>
int main()
{
    int n,a[100001],i=0;
    while(~scanf("%d",&n)&&n!=-1)
    {
        a[i]=n;
        i++;
    }
    for(int j=i-1;j>0;j--)
    {
        printf("%d ",a[j]);
    }
    printf("%d",a[0]);
    return 0;
}

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

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

输入格式:

第一行输入M与N的值。(1 <= M <=100000, 1 <= N <= 100000)

第二行依次输入M个有序的整数。

第三行依次输入N个有序的整数。

输出格式:

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

输入样例:

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

输出样例:

1 14 21 23 26 28 45 50 66 99 100

#include<stdio.h>
void f(int a[], int l, int r)
{
   int x=a[l],i=l,j=r;
   if(i>=j) return;
   while(i<j)
   {
     while(i<j&&a[j]>=x)j--;
     a[i]=a[j];
     while(i<j&&a[i]<=x)i++;
     a[j]=a[i];
   }
   a[i]=x;
   f(a,l,i-1);
   f(a,i+1,r);
}
int main()
{
	int m,n,a[200002],i,j,t;
	scanf("%d %d",&m,&n);
	for(i=0;i<m;i++)
	{
		scanf("%d",&a[i]);
	}
	for(i=m;i<n+m;i++)
	{
		scanf("%d",&a[i]);
	}
	f(a,0,n+m-1);
	for(i=0;i<n+m;i++)
	{
		if(i==n+m-1)
		printf("%d",a[i]);
		else printf("%d ",a[i]);
	}
	return 0;
}

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

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

输入格式:

第一行输入整数N（1<=N<=100000)。

第二行依次输入N个整数。（保证奇数偶数都存在）

输出格式:

第一行分别输出偶数链表与奇数链表的元素个数；

第二行依次输出偶数子链表的所有数据；

第三行依次输出奇数子链表的所有数据。

输入样例:

10
1 3 22 8 15 999 9 44 6 1001

输出样例:

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

#include<stdio.h>
int main()
{
	int n,a[100001],b[100001],c[100001],d=0,e=0,i;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
		if(a[i]%2==0)
		{
			b[d]=a[i];
			d++;
		}
		else
		{
			c[e]=a[i];
			e++;
		}
	}
	printf("%d %d\n",d,e);
	for(i=0;i<d;i++)
	{
		if(i==d-1)
		printf("%d\n",b[i]);
		else printf("%d ",b[i]);
	}
	for(i=0;i<e;i++)
	{
		if(i==e-1)
		printf("%d",c[i]);
		else printf("%d ",c[i]);
	}
	return 0;
}

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

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

输入格式:

第一行输入元素个数 n (1 <= n <= 15)；

第二行输入 n 个整数，保证在 int 范围内。

输出格式:

第一行输出初始链表元素个数；

第二行输出按照逆位序所建立的初始链表；

第三行输出删除重复元素后的单链表元素个数；

第四行输出删除重复元素后的单链表。

输入样例:

10
21 30 14 55 32 63 11 30 55 30

输出样例:

10
30 55 30 11 63 32 55 14 30 21
7
30 55 11 63 32 14 21

#include<stdio.h>
#include<string.h>
int main()
{
	int n,a[16],b[16],c=0,i,j,flag[16];
	scanf("%d",&n);
	memset(flag,0,sizeof(flag));
	for(i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	printf("%d\n",n);
	for(i=n-1;i>=0;i--)
	{
		if(i==0)
		printf("%d\n",a[i]);
		else printf("%d ",a[i]);
	}
	for(i=0;i<n-1;i++)
	{
		for(j=i+1;j<n;j++)
		{
			if(a[j]==a[i])
			{
				flag[i]=1;
				break;
			}
		}
	}
	for(i=0;i<n;i++)
	{
		if(flag[i]==0)
		{
			b[c]=a[i];
			c++;
		}
	}
	printf("%d\n",c);
	for(i=c-1;i>=0;i--)
	{
		if(i==0)printf("%d",b[i]);
		else printf("%d ",b[i]);
	}
	return 0;
}

7 师--链表的结点插入（这个比数组快，我们就不改了）

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

输入格式:

多组输入。

每组数据首先输入一个整数n(1<=n<=100)，代表有n次操作。

接下来的n行，每行有两个整数Mi(0<=Mi<=10000)，Xi。

输出格式:

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

输入样例:

输出样例:

3 1 2 4

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

8 约瑟夫问题

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

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

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

输入格式:

输入n和m值。 (1<=n<=100 , 1<=m<=100)

输出格式:

输出胜利者的编号。

输入样例:

5 3

输出样例:

Hint

第一轮：3被杀

第二轮：1被杀

第三轮：5被杀

第四轮：2被杀

#include<stdio.h>
int main()
{
    int n,m,a[101],count=0,flag=0,i;
    scanf("%d %d",&n,&m);
    if(n==1&&m==1) printf("1");
    else{
    for(i=1;i<=n;i++)
        a[i]=i;
    for(i=1,count=0;;i++)
    {
        if(a[i]!=-1)
        {
            count++;
            if(count==m)
            {
                a[i]=-1;
                count=0;
                flag++;
            }
            if(flag==n)
            {
                printf("%d",i);
                break;
            }
        }
        if(i==n) i=0;
    }
    }
    return 0;
}

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

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

输入格式:

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

输出格式:

对给定的每个关键字，输出此关键字前驱节点关键字和后继节点关键字。如果给定的关键字没有前驱或者后继，则不输出。

注意：每个给定关键字的输出占一行。
一行输出的数据之间有一个空格，行首、行末无空格。

输入样例:

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

输出样例:

2 4
4 6
9

#include<stdio.h>
int main()
{
    int n,m,a[51],i,j;
    scanf("%d %d",&n,&m);
    for(i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    while(m--)
    {
        int x;
        scanf("%d",&x);
        for(i=1;i<=n;i++)
        {
            if(x==a[i])
            {
              if(i==1) printf("%d\n",a[i+1]);
              if(i==n) printf("%d\n",a[i-1]);
              if(i!=1&&i!=n) printf("%d %d\n",a[i-1],a[i+1]);
            }
        }
    }
    return 0;
}

10 不敢死队问题

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

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

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

输入格式:

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

输出格式:

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

输入样例:

输出样例:

2
6
132

#include<stdio.h>
int main()
{
    int m;
    while(~scanf("%d",&m)&&m!=0)
    {
        int count=0,a[10001],i,flag=0;
        if(m==1) printf("1");
        else
        {
        for(i=1;i<=m;i++)
            a[i]=i;
        for(i=1;i<=m;i++)
        {
                if(a[i]!=-1)
                {
                    count++;
                    if(count==5)
                    {
                        if(i!=1)
                        {
                        a[i]=-1;
                        flag++;
                        count=0;
                        }
                        if(i==1)
                        {
                            printf("%d\n",flag+1);
                            break;
                        }
                    }
                }
            if(i==m) i=0;
            }
        }
    }
    return 0;
}