目录
第1关:实现一个顺序存储的线性表
任务描述
本关任务:实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数,以实现线性表中数据的插入、删除与查找等功能。
相关知识
线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中,数据元素之间通过一对一首尾相接的方式连接起来。具体实现时,线性表可以采用不同的存储策略。下面给出了一种基于顺序存储的线性表实现方案:
该方案将线性表存储在一片连续空间里,并通过data、len和max三个属性元素。组织成为一个结构:
·data: 给出线性表存储空间的起始地址;
·max: 指明线性表存储空间最多可存储的数据元素个数;
·len: 当前线性表里的数据元素个数。
为了讨论简化,我们假设每个数据元素是一个整数:
1.typedef int T; // 数据元素的数据类型
该线性表的结构定义如下:
1.struct SeqList{
2. T* data; // 数据元素存储空间的开始地址
3. int len; // 线性表的当前长度
4. int max; // 线性表的最大长度
5. };
以上示意图中的slist是指向该结构的一个指针,只要给定slist指针,就可对线性表进行操作。
对数据元素进行操作处理是一个数据结构的重要组成部分。线性表涉及的主要操作如下:
·创建线性表:创建一个最多可存储max个数据元素的顺序存储的线性表,并将其初始状态设置为len=0。该操作函数具体定义如下,其返回值为slist:
SL_Create(SeqList &slist,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(slist,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 //输出当前线性表的数据元素
/*************************************************************
date: April 2017
copyright: Zhu En
DO NOT distribute this code without my permission.
**************************************************************/
// 顺序表操作实现文件
//
#include <stdio.h>
#include <stdlib.h>
#include "Seqlist.h"
int SL_Create(SeqList &slist,int maxlen)
// 创建一个顺序表。
// 与SqLst_Free()配对。
{
slist.data = (T*)malloc(sizeof(T)*maxlen);
slist.max=maxlen;
slist.len=0;
return 1;
}
void SL_Free(SeqList &slist)
// 释放/删除 顺序表。
// 与SqLst_Create()配对。
{
free(slist.data);
}
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-1) {
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 *********/
for(int j=slist.len;j>i;j--){
slist.data[j]=slist.data[j-1];
}
slist.data[i]=x;
++slist.len;
/********** End **********/
}
T SL_DelAt(SeqList &slist, int i)
// 删除顺序表plist的第i号结点。
// i的有效范围应在[0,plist.len)内,否则会产生异常或错误。
// 返回被删除的数据元素的值。
{
// 在下面的Begin-End之间补充代码,删除第i号结点。
/********** Begin *********/
for(int j=i;j<slist.len-1;j++){
slist.data[j]=slist.data[j+1];
}
--slist.len;
/********** 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 flag=1,local;
for(int i=0;i<slist.len;i++){
if(slist.data[i]==x){
local=i;
flag=0;
break;
}
}
if(flag){
return -1;
}
else{
for(int i=local;i<slist.len-1;i++){
slist.data[i]=slist.data[i+1];
}
--slist.len;
return local;
}
/********** 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
/*************************************************************
date: April 2017
copyright: Zhu En
DO NOT distribute this code without my permission.
**************************************************************/
// 单链表实现文件
#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,否则返回TRUE。
{
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 {
/* 在链表的中间位置或表尾后的位置插入*/
newNode->next = llist->curr->next;
llist->curr->next = newNode;
// llist->pre->next=newNode;
}
/* 增加链表的大小*/
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");
}