目录
第1关：实现一个顺序存储的线性表
任务描述
本关任务要求针对顺序存储的线性表完成三个操作函数，分别实现线性表中数据的插入、删除与查找等功能。
相关知识
线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存储的线性表实现方案：
该方案将线性表存储在一片连续空间里，并通过data、len和max三个属性元素。组织成为一个结构：
data: 给出线性表存储空间的起始地址
max: 指明线性表存储空间最多可存储的数据元素个数
len: 当前线性表里的数据元素个个数
为了讨论简化，我们假设每个数据元素是一个整数:
typedef int T; // 数据元素的数据类型
该线性表的结构定义如下：
struct SeqList{
T* data; // 数据元素存储空间的开始地址
int len; // 线性表的当前长度
int max; // 线性表的最大长度
};
以上示意图中的slist是指向该结构的一个指针，只要给定slist指针，就可对线性表进行操作。
对数据元素进行操作处理是一个数据结构的重要组成部分。线性表涉及的主要操作如下：
创建线性表：创建一个最多可存储max个数据元素的顺序存储的线性表，并将其初始状态设置为len=0。该操作函数具体定义如下，其返回值为slist：
SeqList* SL_Create(int max)
释放线性表存储空间：释放slist->data所指向的用于存储线性表数据元素的存储空间。该操作函数具体定义如下：
void SL_Free(SeqList* slist)
置空线性表：将当前线性表变为一个空表，实现方法是将slist->len设置为0。该操作函数具体定义如下：
void SL_MakeEmpty(SeqList* slist)
获取线性表当前长度：获取并返回线性表的当前长度slist->len。该操作函数具体定义如下：
int SL_Length(SeqList* slist)
判断线性表释放为空：若当前线性表是空表，则返回false,否则返回true。该操作函数具体定义如下：
BOOL SL_IsEmpty(SeqList* slist)
判断线性表释放是否已满：若线性表达到最大长度，则返回 true,否则返回false。该操作函数具体定义如下：
BOOL SL_IsFull(SeqList* slist)
返回线性表第i个数据元素：返回线性表的第i个数据元素slist->data[i]。该操作函数具体定义如下：
T SL_GetAt(SeqList* slist, int i)
修改线性表第i个数据元素： 将线性表的第 i 个数据元素的值修改为 x。该操作函数具体定义如下：
void SL_SetAt(SeqList* slist, int i, T x)
在线性表位置i插入数据元素x： 将x插入slist->data[i]之前。若插入失败(i>slist->len 或i<0时，无法插入)，返回 false，否则返回 true。该操作函数具体定义如下：
BOOL SL_InsAt(SeqList* slist, int i, T x)
删除线性表位置i处的数据元素： 删除线性表的i号数据元素。输入参数i范围应在[0,slist->len-1]内，否则会产生不能预料的异常或错误。返回被删除的数据元素的值。该操作函数具体定义如下：
T SL_DelAt(SeqList* slist, int i)
查找线性表中第一个值为x的数据元素的位置： 找到线性表中第一个值为x的数据元素的编号。返回值-1表示没有找到，返回值>=0表示该元素位置。该操作函数具体定义如下：
int SL_FindValue(SeqList* slist, T x)
删除线性表中第一个值为x的数据元素： 删除第一个值为x的数据元素，返回该数据元素的编号。如果不存在值为x的数据元素，则返回-1。该操作函数具体定义如下：
int SL_DelValue(SeqList* slist, T x)
打印线性表： 打印整个线性表。该操作函数具体定义如下：
void SL_Print(SeqList* slist)
编程要求
本关任务是实现step1/Seqlist.cpp中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数，以实现线性表中数据的插入、删除与查找等功能。具体要求如下：
* SL_InsAT: 在顺序表的位置i插入结点x, 插入d[i]之前,i的有效范围[0,slist->len]
* SL_DelAt:删除顺序表slist的第i号结点, i的有效范围应在[0,slist->len)内，否则会产生异常或错误。返回被删除的数据元素的值。
* SL_DelValue:删除第一个值为x的结点,存在值为x的结点则返回结点编号, 未找到返回－1
输入输出格式请参见后续测试样例
注意：本关必读中提及的其他操作已经由平台实现，你在实现本关任务的三个操作函数时，在函数体内可调用其他操作。
本关涉及的代码文件Seqlist.cpp中的3个操作函数的代码框架如下：
bool SL_InsAt(SeqList* slist, int i, T x)
// 在顺序表的位置i插入结点x, 插入在d[i]之前。i的有效范围[0,slist->len]
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
/********** End **********/
}
T SL_DelAt(SeqList* slist, int i)
// 删除顺序表slist的第i号结点（i的有效范围应在[0,slist->len)内，否则会产生异常或错误）。返回被删除的数据元素的值。
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
/********** End **********/
}
int SL_DelValue(SeqList* slist, T x)
// 删除第一个值为x的结点。存在值为x的结点则返回结点编号, 未找到则返回－1
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
/********** End **********/
}
测试说明
本关的测试文件是step1/Main.cpp，负责对实现的代码进行测试。具体代码如下：
#include <stdio.h>
#include <stdlib.h>
#include "SeqList.h"
#pragma warning(disable:4996)
void main()
{
//设置线性表最多可存储的元素个数max
int max=100;
//创建一个长度为max的空线性表
SeqList* slist=SL_Create(max);
//声明并读入线性表当前长度n
int n;
scanf("%d", &n);
int i;
int item;
//循环读入n个整数，并存入到线性表中
for (i=0; i<n; i++){
scanf("%d", &item);
SL_InsAt(slist, i, item);
}
//读入一个整数idel，并将线性表中位置idel处的数据元素删除
int idel;
scanf("%d", &idel);
SL_DelAt(slist, idel);
//读入一个整数整itemdel，并将线性表中第一次出现该值的数据元素删除
int itemdel;
scanf("%d", &itemdel);
SL_DelValue(slist, itemdel);
SL_Print(slist);
//释放线性表空间
SL_Free(slist);
}
注意：step1/Main.cpp的代码不能被修改。
以下是平台对step1/Main.cpp的测试样例：
样例输入:
5 //输入线性表的长度
8 9 12 33 45 //依次输入线性表的数据元素
2 //删除线性表的2号数据元素
33 //删除值为33的数据元素
样例输出
8 9 45 //输出当前线性表的数据元素
// 顺序表操作实现文件
//
#include <stdio.h>
#include <stdlib.h>
#include "Seqlist.h"
SeqList* SL_Create(int maxlen)
// 创建一个顺序表。
// 与SqLst_Free()配对。
{
SeqList* slist=(SeqList*)malloc(sizeof(SeqList));
slist->data = (T*)malloc(sizeof(T)*maxlen);
slist->max=maxlen;
slist->len=0;
return slist;
}
void SL_Free(SeqList* slist)
// 释放/删除 顺序表。
// 与SqLst_Create()配对。
{
free(slist->data);
free(slist);
}
void SL_MakeEmpty(SeqList* slist)
// 置为空表。
{
slist->len=0;
}
int SL_Length(SeqList* slist)
// 获取长度。
{
return slist->len;
}
bool SL_IsEmpty(SeqList* slist)
// 判断顺序表是否空。
{
return 0==slist->len;
}
bool SL_IsFull(SeqList* slist)
// 判断顺序表是否满。
{
return slist->len==slist->max;
}
T SL_GetAt(SeqList* slist, int i)
// 获取顺序表slist的第i号结点数据。
// 返回第i号结点的值。
{
if(i<0||i>=slist->len) {
printf("SL_GetAt(): location error when reading elements of the slist!\n");
SL_Free(slist);
exit(0);
}
else
return slist->data[i];
}
void SL_SetAt(SeqList* slist, int i, T x)
// 设置第i号结点的值（对第i号结点的数据进行写）。
{
if(i<0||i>=slist->len) {
printf("SL_SetAt(): location error when setting elements of the slist!\n");
SL_Free(slist);
exit(0);
}
else
slist->data[i]=x;
}
bool SL_InsAt(SeqList* slist, int i, T x)
// 在顺序表的位置i插入结点x, 插入d[i]之前。
// i 的有效范围[0,plist->len]。
{
// 请在下面的Begin-End之间补充代码，插入结点。
/********** Begin *********/
int k;
if(i<0||i>slist->len||slist->len==slist->max)
{
return false;
}
//if(slist->len>=max-1)
//{
//printf("表已经装满无法插入");
//printf("ERROR!!!");
// return false;
//}
for(k=slist->len;k>=i;k--)
slist->data[k+1]=slist->data[k];
slist->data[i]=x;
slist->len++;
return true;
/********** End **********/
}
T SL_DelAt(SeqList* slist, int i)
// 删除顺序表plist的第i号结点。
// i的有效范围应在[0,plist->len)内，否则会产生异常或错误。
// 返回被删除的数据元素的值。
{
// 在下面的Begin-End之间补充代码，删除第i号结点。
/********** Begin *********/
if(i<0||i>slist->len) return false;
T t=slist->data[i];
for(int j=i;j<slist->len-1;j++)
{
slist->data[j]=slist->data[j+1];
}
slist->len--;
return t;
/********** End **********/
}
int SL_FindValue(SeqList* slist, T x)
// 在顺序表表中查找第一个值为x的结点，返回结点的编号。
// 返回值大于等于0时表示找到值为x的结点的编号，-1表示没有找到。
{
int i=0;
while(i<slist->len && slist->data[i]!=x) i++;
if (i<slist->len) return i;
else return -1;
}
int SL_DelValue(SeqList* slist, T x)
// 删除第一个值为x的结点。
// 存在值为x的结点则返回结点编号, 未找到返回－1。
{
// 在下面的Begin-End之间补充代码，删除第一个值为 x 的结点。
/********** Begin *********/
int j=SL_FindValue(slist,x);
if(j!=-1)
{
SL_DelAt(slist, j);
}
return j;
/********** End **********/
}
void SL_Print(SeqList* slist)
// 打印整个顺序表。
{
if (slist->len==0) {
printf("The slist is empty.\n");
return;
}
//printf("The slist contains: ");
for (int i=0; i<slist->len; i++) {
printf("%d ", slist->data[i]);
}
printf("\n");
}第2关：实现一个链接存储的线性表
任务描述
本关任务要求针对链接存储方式实现的顺序表完成数据插入操作函数，以实现线性表数据插入功能。
相关知识
线性表的存储也可以采用链接存储方式来实现。链接存储方式包括包括单链表、双链表和循环链表等形式。
下面描述了一种基于单链表的线性表实现方案：
为了讨论简单，假设数据元素的类型为整数：
typedef int T;
在链表中，每个数据元素为一个链表结点，结点的具体定义为：
struct LinkNode {
T data;
LinkNode* next;
};
如上面的单链表示意图所示，一个链表主要有front、rear、curr、position和len等属性要素组织成一个结构：
front： 指向链表的首结点
rear： 指向尾结点
curr： 指向操作的当前位置（见后文特别说明）的结点
pre： 指向当前位置的前一个结点
position： 是当前位置的编号（编号从0开始）
len： 数据元素的个数（即链表的长度）
基于这些属性要素，可以将线性表组织为一个链表结构：
struct LinkList {
LinkNode* front; // 指向头结点
LinkNode* rear; // 指向尾结点
LinkNode* pre; // 指向当前位置结点的前一个结点
LinkNode* curr; // 指向当前位置结点
int position; // 当前位置结点的编号
int len; // 线性表的大小（链表结点数）
};
给定指向该结构的一个指针llist，就可以对链接存储的线性表进行操作。
特别说明:
“当前位置”：当前位置由curr指针给出，当前位置的前一个位置由pre指针给出，当前位置的编号由position给出。后面将定义的若干操作与当前位置有关，例如：在当前位置结点之前插入结点，在当前位置结点之后插入结点，等等。当为空链表时，curr和pre都为空指针，position为0。当前位置在非空链表的最左端时，pre为空指针，curr指向头结点，position=0。当前位置在非空链表的最右端时,pre指向尾结点，curr为空指针，position等于len。
针对链表数据，我们定义如下操作：
创建空线性表：创建一个链接存储的线性表，初始为空表，返回llist指针。具体操作函数定义如下：
LinkList* LL_Create()
释放线性表节点：释放链表的结点，然后释放llist所指向的结构。具体操作函数定义如下：
void LL_Free(LinkList* llist)
置空线性表：释放所有结点释放链表的结点,将当前线性表变为一个空表。具体操作函数定义如下：
void LL_MakeEmpty(LinkList* llist)
获取线性表当前长度： 返回线性表的当前长度。具体操作函数定义如下：
int LL_Length(LinkList* llist)
判断线性表是否为空： 若当前线性表是空表，则返回true，否则返回false。具体操作函数定义如下：
bool LL_IsEmpty(LinkList* llist)
设置线性表当前位置： 设置线性表的当前位置为i号位置。设置成功，则返回true，否则返回false（线性表为空，或i不在有效的返回）。假设线性表当前长度为len，那么i的有效范围为[0,len]。具体操作函数定义如下：
bool LL_SetPosition(LinkList* llist, int i)
获取线性表当前位置节点编号： 获取线性表的当前位置结点的编号。具体操作函数定义如下：
int LL_GetPosition(LinkList* llist)
设置线性表当前位置的下一位置为当前位置： 设置成功，则返回true，否则返回false（线性表为空，或当前位置为表尾）。具体操作函数定义如下：
bool LL_NextPosition(LinkList* llist)
获取线性表当前位置的数据元素的值： 具体操作函数定义如下：
T LL_GetAt(LinkList* llist)
修改线性表当前位置数据元素的值： 将线性表的当前位置的数据元素的值修改为x。具体操作函数定义如下：
void LL_SetAt(LinkList* llist, T x)
在线性表当前位置之前插入数据元素： 在线性表的当前位置之前插入数据元素x。空表允许插入，当前位置指针将指向新结点。若插入失败，返回false，否则返回true。具体操作函数定义如下：
bool LL_InsAt(LinkList* llist, T x)
在线性表当前位置之后插入数据元素： 在线性表的当前位置之后插入数据元素x。空表允许插入，当前位置指针将指向新结点。若插入失败，返回false，否则返回true。具体操作函数定义如下：
bool LL_InsAfter(LinkList* llist, T x)
删除线性表当前位置数据元素节点： 若删除失败（为空表），则返回false，否则返回true。具体操作函数定义如下：
bool LL_DelAt(LinkList* llist)
删除线性表当前位置后面的那个数据元素节点： 若删除失败（为空表，或当前位置时表尾），则返回false，否则返回true。具体操作函数定义如下：
bool LL_DelAfter(LinkList* llist)
查找线性表中第一个值为x的数据元素的编号： 返回值-1表示没有找到，返回值>=0表示编号。具体操作函数定义如下：
int LL_FindValue(LinkList* llist, T x)
删除线性表中第一个值为x的数据元素： 删除第一个值为x的数据元素，返回该数据元素的编号。如果不存在值为x的数据元素，则返回-1。具体操作函数定义如下：
int LL_DelValue(LinkList* llist, T x)
打印整个线性表： 具体操作函数定义如下：
void LL_Print(LinkList* llist)
编程要求
本关任务是实现step2/LinkList.cpp中的LL_InsAfter操作函数，以实现线性表数据插入功能。具体要求如下：
* 在线性表的当前位置之后插入数据元素x。空表允许插入，当前位置指针将指向新结点。若插入失败，返回false，否则返回true
输入输出格式请参见后续测试样例
注意：本关必读中提及的其他操作函数已经由平台实现，你在实现操作LL_InsAfter时，在函数体内可调用其他操作函数。
本关涉及的LinkList.cpp中的LL_InsAfter操作函数的代码框架如下：
bool LL_InsAfter(LinkList* llist, T x)
// 在线性表的当前位置之后插入数据元素x。空表允许插入。当前位置指针将指向新结点。若插入失败，返回false，否则返回true。
{
// 请在这里补充代码，完成本关任务
/********** Begin *********/
/********** End **********/
}
测试说明
本关的测试文件是step2/Main.cpp，负责对你实现的代码进行测试。具体代码如下：
#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"
#pragma warning(disable:4996)
int main()
{
//创建一个线性表
LinkList* llist=LL_Create();
//向线性表中插入a个数据元素
int i;
int x;
int a;
scanf("%d", &a);
for(i=0; i<a; i++) {
scanf("%d",&x);
LL_InsAfter(llist,x);
}
//设置线性表当前位置为0
LL_SetPosition(llist, 0);
//在线性表表头顺序插入a个元素
scanf("%d", &a);
for(i=0; i<a; i++) {
scanf("%d", &x);
LL_SetPosition(llist,0);
LL_InsAfter(llist,x);
}
//删除线性表中第一个值为x的元素节点
scanf("%d", &x);
LL_DelValue(llist, x);
//设置当前位置为i，并删除该位置的元素节点
scanf("%d", &i);
LL_SetPosition(llist, i);
LL_DelAt(llist);
//打印整个线性表然后释放线性表空间
LL_Print(llist);
system("PAUSE");
LL_Free(llist);
}
注意：step2/Main.cpp的代码不能被修改。
以下是平台对step2/Main.cpp的测试样例：
样例输入:
3 //输入一个数a，后面将输入a个数据元素
8 9 3 //a个数据元素，依次插入尾结点后。形成单链表结点序列：8,9,3
3 //输入一个数b，后面将再输入b个数据元素
10 89 22 //b个数据元素，依次插入0号结点后。形成单链表结点序列：8,22,89,10,9,3
89 //删除一个值为89的结点
1 //删除1号结点
样例输出
8 10 9 3
#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"
// 1）
LinkList* LL_Create()
// 创建一个链接存储的线性表，初始为空表，返回llist指针。
{
LinkList* llist=(LinkList*)malloc(sizeof(LinkList));
llist->front=NULL;
llist->rear=NULL;
llist->pre=NULL;
llist->curr=NULL;
llist->position=0;
llist->len=0;
return llist;
}
// 2）
void LL_Free(LinkList* llist)
// 释放链表的结点，然后释放llist所指向的结构。
{
LinkNode* node=llist->front;
LinkNode* nextnode;
while(node){
nextnode=node->next;
free(node);
node=nextnode;
}
free(llist);
}
// 3）
void LL_MakeEmpty(LinkList* llist)
// 将当前线性表变为一个空表，因此需要释放所有结点。
{
LinkNode* node=llist->front;
LinkNode* nextnode;
while(node){
nextnode=node->next;
free(node);
node=nextnode;
}
llist->front=NULL;
llist->rear=NULL;
llist->pre=NULL;
llist->curr=NULL;
llist->position=0;
llist->len=0;
}
// 4）
int LL_Length(LinkList* llist)
// 返回线性表的当前长度。
{
return llist->len;
}
// 5）
bool LL_IsEmpty(LinkList* llist)
// 若当前线性表是空表，则返回true，否则返回 False。
{
return llist->len==0;
}
// 6）
bool LL_SetPosition(LinkList* llist, int i)
// 设置线性表的当前位置为i号位置。
// 设置成功，则返回true，否则返回false（线性表为空，或i不在有效的返回）。
// 假设线性表当前长度为len，那么i的有效范围为[0,len]。
{
int k;
/* 若链表为空，则返回*/
if (llist->len==0) return false;
/*若位置越界*/
if( i < 0 || i > llist->len)
{ printf("LL_SetPosition(): position error");
return false;
}
/* 寻找对应结点*/
llist->curr = llist->front;
llist->pre = NULL;
llist->position = 0;
for ( k = 0; k < i; k++) {
llist->position++;
llist->pre = llist->curr;
llist->curr = (llist->curr)->next;
}
/* 返回当前结点位置*/
return true;
}
// 7)
int LL_GetPosition(LinkList* llist)
// 获取线性表的当前位置结点的编号。
{
return llist->position;
}
// 8）
bool LL_NextPosition(LinkList* llist)
// 设置线性表的当前位置的下一个位置为当前位置。
// 设置成功，则返回true，否则返回false（线性表为空，或当前位置为表尾）。
{
if (llist->position >= 0 && llist->position < llist->len)
/* 若当前结点存在，则将其后继结点设置为当前结点*/
{
llist->position++;
llist->pre = llist->curr;
llist->curr = llist->curr->next;
return true;
}
else
return false;
}
// 9）
T LL_GetAt(LinkList* llist)
// 返回线性表的当前位置的数据元素的值。
{
if(llist->curr==NULL)
{
printf("LL_GetAt(): Empty list, or End of the List.\n");
LL_Free(llist);
exit(1);
}
return llist->curr->data;
}
// 10）
void LL_SetAt(LinkList* llist, T x)
// 将线性表的当前位置的数据元素的值修改为x。
{
if(llist->curr==NULL)
{
printf("LL_SetAt(): Empty list, or End of the List.\n");
LL_Free(llist);
exit(1);
}
llist->curr->data=x;
}
// 11）
bool LL_InsAt(LinkList* llist, T x)
// 在线性表的当前位置之前插入数据元素x。当前位置指针指向新数据元素结点。
// 若插入失败，返回false，否则返回true。
{
LinkNode *newNode=(LinkNode*)malloc(sizeof(LinkNode));
if (newNode==NULL) return false;
newNode->data=x;
if (llist->len==0){
/* 在空表中插入*/
newNode->next=NULL;
llist->front = llist->rear = newNode;
}
//当前位置为表头。
else if (llist->pre==NULL)
{
/* 在表头结点处插入*/
newNode->next = llist->front;
llist->front = newNode;
}
else {
/* 在链表的中间位置或表尾后的位置插入*/
newNode->next = llist->curr;
llist->pre->next=newNode;
}
//插入在表尾后。
if (llist->pre==llist->rear)
llist->rear=newNode;
/* 增加链表的大小*/
llist->len++;
/* 新插入的结点为当前结点*/
llist->curr = newNode;
return true;
}
// 12）
bool LL_InsAfter(LinkList* llist, T x)
// 在线性表的当前位置之后插入数据元素x。空表允许插入。当前位置指针将指向新结点。
// 若插入失败，返回false，否则返回true。
{
// 请在Begin-End之间补充代码，实现结点插入。
/********** Begin *********/
LinkNode *newNode=(LinkNode*)malloc(sizeof(LinkNode));
if(newNode==NULL) return false;
newNode->data=x;
if(llist->len==0)
{
newNode->next=NULL;
llist->front=llist->rear=newNode;
}
else if(llist->curr==llist->rear|| llist->curr == NULL)
{
newNode->next=NULL;
llist->rear->next=newNode;
llist->pre=llist->rear;
llist->rear=newNode;
llist->position=llist->len;
}
else
{
newNode->next=llist->curr->next;
llist->curr->next=newNode;
llist->pre=llist->curr;
llist->position++;
}
llist->len++;
llist->curr=newNode;
return true;
/********** End **********/
}
// 13）
bool LL_DelAt(LinkList* llist)
// 删除线性表的当前位置的数据元素结点。
// 若删除失败（为空表，或当前位置为尾结点之后），则返回false，否则返回true。
{
LinkNode *oldNode;
/* 若表为空或已到表尾之后，则给出错误提示并返回*/
if (llist->curr==NULL)
{
printf("LL_DelAt(): delete a node that does not exist.\n");
return false;
}
oldNode=llist->curr;
/* 删除的是表头结点*/
if (llist->pre==NULL)
{
llist->front = oldNode->next;
}
/* 删除的是表中或表尾结点*/
else if(llist->curr!=NULL){
llist->pre->next = oldNode->next;
}
if (oldNode == llist->rear) {
/* 删除的是表尾结点，则修改表尾指针和当前结点位置值*/
llist->rear = llist->pre;
}
/* 后继结点作为新的当前结点*/
llist->curr = oldNode->next;
/* 释放原当前结点*/
free(oldNode);
/* 链表大小减*/
llist->len --;
return true;
}
// 14）
bool LL_DelAfter(LinkList* llist)
// 删除线性表的当前位置的后面那个数据元素。
// 若删除失败（为空表，或当前位置时表尾），则返回false，否则返回true。
{
LinkNode *oldNode;
/* 若表为空或已到表尾，则给出错误提示并返回*/
if (llist->curr==NULL || llist->curr== llist->rear)
{
printf("LL_DelAfter(): delete a node that does not exist.\n");
return false;
}
/* 保存被删除结点的指针并从链表中删除该结点*/
oldNode = llist->curr->next;
llist->curr->next=oldNode->next;
if (oldNode == llist->rear)
/* 删除的是表尾结点*/
llist->rear = llist->curr;
/* 释放被删除结点*/
free(oldNode);
/* 链表大小减*/
llist->len --;
return true;
}
// 15）
int LL_FindValue(LinkList* llist, T x)
// 找到线性表中第一个值为x的数据元素的编号。
// 返回值-1表示没有找到，返回值>=0表示编号。
{
LinkNode* p=llist->front;
int idx=0;
while(p!=NULL && p->data!=x) {
idx++;
p = p->next;
}
if (idx>=llist->len) return -1;
else return idx;
}
// 16）
int LL_DelValue(LinkList* llist, T x)
// 删除第一个值为x的数据元素，返回该数据元素的编号。如果不存在值为x的数据元素，则返回-1。
{
int idx=LL_FindValue(llist, x);
if (idx<0) return -1;
LL_SetPosition(llist, idx);
LL_DelAt(llist);
return idx;
}
// 17）
void LL_Print(LinkList* llist)
// 打印整个线性表。
{
LinkNode* node=llist->front;
while (node) {
printf("%d ", node->data);
node=node->next;
}
printf("\n");
}第3关：就地归并两个有序表
任务描述
本关任务：编程实现两个有序表的就地归并。
相关知识
为了完成本关任务，你需要掌握：1.单链表的存储；2.单链表的基本操作。
注意事项
1.已有的两个有序表使用带头结点的单链表的存储方式
2.归并以后不允许表中有重复元素
3.就地归并
编程要求
首先建立两个有序单链表，就地归并后输出。
测试说明
平台会对你编写的代码进行测试：
7 //输入第一个表的长度n1
2 4 7 8 10 13 18 //依次输入n1个有序的元素
5 /输入第一个表的长度n2
3 4 5 6 9 //依次输入n2个有序的元素
预期输出：
归并表为：2 3 4 5 6 7 8 9 10 13 18
//有序表就地归并
#include<stdio.h>
#include<malloc.h>
typedef struct list {
int data;
struct list * next; //下一个节点地址
}list;
//第一条链表
struct list * L=NULL;//头
struct list * head=NULL;//首
struct list * p=NULL;
//第二条链表
struct list * L1=NULL;//头
struct list * head1=NULL;//首
struct list * p1=NULL;
//代理链表
struct list * L2=NULL;//头
struct list * q=NULL;//L2备用地址
struct list * q1=NULL;//备用地址
int main(){
int i=0,length;
scanf("%d",&length);
head=(struct list *)malloc(sizeof(struct list));
L=head;
for(i;i<length;i++){
p = (struct list *)malloc(sizeof(struct list));
scanf("%d",&p->data);
p->next=NULL;
head->next=p;
head=p;
}
int i1=0,length1;
scanf("%d",&length1);
head1=(struct list *)malloc(sizeof(struct list));
L1=head1;
for(i1;i1<length1;i1++){
p1= (struct list *)malloc(sizeof(struct list));
scanf("%d",&p1->data);
p1->next=NULL;
head1->next=p1;
head1=p1;
}
L2=(struct list *)malloc(sizeof(struct list));
q=L2;//备用合并链表起始地址
p=L->next;
p1=L1->next;
while(p&&p1){
if(p->data<p1->data){
L2->next=p;
L2=p;
p=p->next;
}else if(p->data==p1->data){
L2->next=p;
L2=p;
p=p->next;
q1=p1->next;//备用相同元素的下一个地址指向
free(p1);
p1=q1;
}else if(p->data>p1->data){
L2->next=p1;
L2=p1;
p1=p1->next;
}
}
L2->next=p?p:p1;
free(L1);
printf("预期输出:");
p=q->next;
while(p){
printf("%d ",p->data);
p=p->next;
}
}
第4关：两个一元多项式异地相加
任务描述
本关任务：设计一个一元稀疏多项式简单计算器。
基本要求
需要完成一元稀疏多项式简单计算器的基本功能是：
（1）输入并建立多项式；
（2）输出多项式，输出形式为如下序列：c1，e1，c2，e2，…，cn，en，其中ｎ是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数升序排列；
（3）实现多项式相加：C=A＋B；
实现提示
用顺序表或者带表头结点的单链表存储多项式都可以
编程要求
根据下免得测试说明提示，在右侧编辑器编写代码，测试通过方可得分
测试说明
平台会对你编写的代码进行测试：
示例1：
输入：A=2x+5x8-3.1x11，B=7-5x8+11x9，
输出：C=A+B=7+2x+11x9-3.1x11
测试输入: 3 //第一个多项式包含3项
2 1 5 8 -3.1 11;//依次输入每一项的系数和指数，空格隔开
3 //第二个多项式包含3项
7 0 -5 8 11 9;//依次输入每一项的系数和指数，空格隔开
预期输出：
7 0 2 1 11 9 -3.1 11;
示例2：
输入：A=x+x3，B=-x-x3，
输出：C=A+B=0
测试输入: 2 //第一个多项式包含2项
1 1 1 3;//依次输入每一项的系数和指数，空格隔开
2 //第二个多项式包含2项
-1 1 -1 3;//依次输入每一项的系数和指数，空格隔开
预期输出：
0;
/*
提示：
一元多项式的创建和加减 (链式、带头结点)
数据结构类型定义及实现
包含以下函数
创建一元多项式、打印、销毁
相加、相减
请在下面编写你的代码：
*/
#include<stdio.h>
#include<stdlib.h>
#define LEN sizeof(Poly)
typedef struct term {
float coef; //系数
int expn; //指数
struct term* next;
}Poly, * Link;
void CreatePolyn(Link* p, int m);
void PrintPolyn(Link p);
int cmp(Link p1, Link p2);
Link AddPolyn(Link pa, Link pb);
int main()
{
Link P1, P2;
int L1, L2;
//printf("请输入第一个多项式的项数：");
scanf("%d", &L1);
CreatePolyn(&P1, L1);
//printf("第一个多项式为：");
//PrintPolyn(P1);
//printf("请输入第二个多项式的项数：");
scanf("%d", &L2);
CreatePolyn(&P2, L2);
//printf("第二个多项式为：");
//PrintPolyn(P2);
printf("\n");
//printf("两个一元多项式相加的结果为：");
PrintPolyn(AddPolyn(P1, P2));
}
void CreatePolyn(Link* p, int m)//*p是双重指针，用此意在改变指针
//创建多项式（带头结点），基础：动态链表的创建
{
Link r, s;
int i;
*p = (Link)malloc(LEN);
r = *p;
for (i = 0; i < m; i++)
{
s = (Link)malloc(LEN);
//printf("输入系数和指数（以空格隔开）:");
scanf("%f %d", &s->coef, &s->expn);
r->next = s;
r = s;
}
r->next = NULL;
}
void PrintPolyn(Link p)
//打印显示多项式，基础：遍历链表
{
Link s;
s = p->next;
if (s==NULL)
{
printf("0");
}
while (s)
{
printf("%g %d ", s->coef, s->expn);
s = s->next;
}
printf("\n");
}
int cmp(Link a, Link b)
//比较两项的指数的大小，并返回特定的值。
{
if (a->expn < b->expn) return -1;
else if (a->expn == b->expn) return 0;
else return 1;
}
Link AddPolyn(Link pa, Link pb)//pa, pb是两个指向头结点的指针
//两个多项式相加得一个新多项式，并且返回新多项式的头结点的指针
{
Link newp, p, q, s, pc;
float sum;
p = pa->next; //p指向pa的第一个元素
q = pb->next; //q指向pb的第一个元素
newp = (Link)malloc(LEN); //pc指向新多项式pc的头结点
pc = newp;
while (p && q) {
switch (cmp(p, q))
{
case -1: //若指数：p<q,则将p所指结点链入头结点为newp的链表中，且p向后遍历
s = (Link)malloc(LEN);
s->coef = p->coef;
s->expn = p->expn;
pc->next = s;
pc = s;
p = p->next;
break;
case 0://若比较两项的指数相等，则将两项系数相加后得到的项放入头结点为newp的链表中 ，且p,q同时向后遍历
sum = p->coef + q->coef;
if (sum = 0)//若两项系数相加为0，则不放入头结点为newp的链表中
{
s = (Link)malloc(LEN);
s->coef = sum;
s->expn = p->expn;
pc->next = s;
pc = s;
}
p = p->next;
q = q->next;
break;
case 1: //若指数：q<p,则将q所指结点链入头结点为newp的链表中，且q向后遍历
s = (Link)malloc(LEN);
s->coef = q->coef;
s->expn = q->expn;
pc->next = s;
pc = s;
q = q->next;
break;
}
}
while (p) //若p所在链表还有剩余项，直接将剩余项依次链入头结点为newp的链表中
{
s = (Link)malloc(LEN);
s->coef = p->coef;
s->expn = p->expn;
pc->next = s;
pc = s;
p = p->next;
}
while (q)//若q所在链表还有剩余项，直接将剩余项依次链入头结点为newp的链表中
{
s = (Link)malloc(LEN);
s->coef = q->coef;
s->expn = q->expn;
pc->next = s;
pc = s;
q = q->next;
}
pc->next = NULL;
return newp; //返回新多项式的首地址
}
第5关：约瑟夫环问题
任务描述
本关任务：约瑟夫环问题的描述是：编号为1，2，…，n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为一个新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。请设计一个程序求出列顺序。
基本要求
利用单向循环链表存储结构模拟此过程，按照出列顺序打印出各人的编号。
编程要求
根据任务要求，在右侧编辑器编写代码，通过所有测试集方可得分。
测试说明
平台会对你编写的代码进行测试：
输入：m的初值为20；
n=7；
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；
/*
约瑟夫环Josephus(循环单链表、无头结点)
约瑟夫问题：
输入N 和 M ,N为参入游戏的人数,M为指定序号(报到该数字的人受惩罚)
N个人有固定编号，按编号顺序报数,报道M的人受惩罚,最后有一人幸存,
输出依次受惩罚的人的编号
不要输入打印信息，请在下面完成你的任务！
*/
#include<stdio.h>
#include<stdlib.h>
typedef struct
{
int number;
int cipher;
}DataType;
typedef struct node
{
DataType data;
struct node *next;
}SCLNode;
void SCLLInitiate(SCLNode **head)
{
if((*head=(SCLNode*)malloc(sizeof(SCLNode)))==NULL)
exit(1);
(*head)->next=*head;
}
int SCLLInsert(SCLNode *head,int i,DataType x)
{
SCLNode *p,*q;
int j;
p=head->next;
j=1;
while(p!=head&&j<i-1)
{
p=p->next;
j++;
}
if(j!=i-1&&i!=1)
{
printf("插入位置参数错!");
return 0;
}
if((q=(SCLNode*)malloc(sizeof(SCLNode)))==NULL)
exit(1);
q->data=x;
q->next=p->next;
p->next=q;
return 1;
}
int SCLLDelete(SCLNode *head,int i,DataType *x)
{
SCLNode *p,*q;
int j;
p=head;
j=0;
while(p->next!=head&&j<i-1)
{
p=p->next;
j++;
}
if(j!=i-1)
{
printf("删除位置参数错!");
return 0;
}
q=p->next;
p->next=p->next->next;
*x=q->data;
free(q);
return 1;
}
int SCLLGet(SCLNode *head,int i,DataType *x)
{
SCLNode *p;
int j;
p=head;
j=0;
while(p->next!=head&&j<i)
{
p=p->next;
j++;
}
if(j!=i)
{
printf("取元素位置参数错!");
return 0;
}
*x=p->data;
return 1;
}
int SCLLNotEmpty(SCLNode *head)
{
if(head->next==head)
return 0;
else
return 1;
}
void SCLLDeleteAfter(SCLNode *p)
{
SCLNode *q=p->next;
p->next=p->next->next;
free(q);
}
void JesephRing(SCLNode *head,int m)
{
SCLNode *pre,*curr;
int i;
pre=head;
curr=head->next;
while(SCLLNotEmpty(head)==1)
{
for(i=1;i<m;i++)
{
pre=curr;
curr=curr->next;
if(curr==head)
{
pre=curr;
curr=curr->next;
}
}
printf("%d ",curr->data.number);
m=curr->data.cipher;
curr=curr->next;
if(curr==head)
curr=curr->next;
SCLLDeleteAfter(pre);
}
}
int main()
{
DataType test[7]={{1,3},{2,1},{3,7},{4,2},{5,4},{6,8},{7,4}};
int n=7,m=20,i;
SCLNode *head;
SCLLInitiate(&head);
for(i=1;i<=n;i++)
SCLLInsert(head,i,test[i-1]);
JesephRing(head,m);
return 0;
}
扫一扫
471
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
