【EduCoder实训作业】数据结构 - 线性表

最新推荐文章于 2023-01-23 20:26:12 发布
最新推荐文章于 2023-01-23 20:26:12 发布
阅读量3.8k 收藏 19
点赞数 6
分类专栏： EduCcoder题及题解 文章标签： 数据结构 r语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55205575/article/details/121169474
版权

数据结构 - 线性表

第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; // 线性表的最大长度 };

以上示意图中的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 *********/
    if(i<0||i>slist->len||slist->len==slist->max)
    {
        return false;
    }
    for(int j=slist->len;j>=i;j--)
    {
        slist[j+1]=slist[j];
    }
    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 0;
    int e=slist->data[i];
    for(int j=i;j<slist->len-1;j++)
    {
        slist->data[j]=slist->data[j+1];
    }
    slist->len--;
    return e;
 
 
    /********** 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

/*************************************************************
    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，否则返回 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->rear = newNode;
        llist->position++;
    }
    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");
}
云yun云\^O^/
关注
  • 6
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
educoder数据结构与算法 线性表 第1关：实现一个顺序存储的线性表
兴趣使然的编程菜鸟
01-02 2061
注意：本关必读中提及的其他操作已经由平台实现，你在实现本关任务的三个操作函数时，在函数体内可调用其他操作。本关的测试文件是 step1/Main.cpp ，负责对实现的代码进行测试。返回被删除的数据元素的值。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。所指向的用于存储线性表数据元素的存储空间。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。个数据元素的顺序存储的线性表，并将其初始状态设置为。的数据元素，返回该数据元素的编号。获取线性表当前长度：获取并返回线性表的当前长度。
头歌：实现顺序表中数据的查找功能
m0_73147943的博客
03-23 8090
头歌实践教学平台数据结构的 1数据结构-顺序表及其应用的答案
链表的实现之查找功能
Acceleration_的博客
03-27 6306
#include <stdio.h> #include <stdlib.h> #include "LinkList.h" void LL_Initiate(LinkList &L) //单链表的初始化，即：构造一个带头结点的空的单链表 { L=(LNode *)malloc(sizeof(LNode)); L->next=NULL; } void LL_Free(LinkList &L) // 释放链表中各个结点。 { LinkList p;.
数据结构与算法 - 队列
aiains的博客
10-24 2702
数据结构
1.顺序表的各种基本操作（函数原型）
everlastingYu的博客
04-15 766
void InitList(SqList *&amp;L)          //初始化线性表，构造一个空的线性表，并将长度设置为0   { L = (SqList *)malloc(sizeof(SqList)); L-&gt;length = 0; } void DestroyList(SqList *L)        //销毁线性表，即释放线性表所占用的内存空间   { f...
数据结构-线性表-PPT
02-04
"数据结构-线性表-PPT" 数据结构是一门研究非数值计算的程序设计问题的学科，它研究的是计算机存储、表示、操作和保护非数值信息的方法和技术。线性表是数据结构的一种基本结构，它是一种线性结构，只有一个首结点...
数据结构--线性表--思维导图.pdf
08-29
数据结构--线性表--思维导图.pdf 该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的...
数据结构-线性表-xmind思维导图
05-13
串、栈、队列的区分度在于数据的运算和逻辑结构，而他们的存储结构常用的都是顺序表和链表。 广义表和数组都是更抽象的线性表，数组对数据元素要求更严苛，广义表则是放开了数据元素的限定。他们都可以是递归定义，...
数据结构-线性表的链式存储
最新发布
09-17
数据结构——线性表的链式存储。 一篇文章带你快速了解！
数据结构--线性表.cpp
03-08
数据结构--线性表.cpp
c语言seqlist用法,c语言学习之顺序表操作
weixin_28684825的博客
05-25 1706
//seqlist.h#ifndef _SEQLIST_H_#define _SEQLIST_H_#define MAXSIZE 100typedef struct{int listLen; //节点数量DATA_T dataList[MAXSIZE+1];}seqListType;/* 初始化顺序表 */void seqlist_init(seqListType *sl);/* 返回顺...
第1关：实现一个顺序存储的线性表
m0_62752579的博客
11-01 3566
注意：本关必读中提及的其他操作已经由平台实现，你在实现本关任务的三个操作函数时，在函数体内可调用其他操作。本关的测试文件是 step1/Main.cpp ，负责对实现的代码进行测试。返回被删除的数据元素的值。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。所指向的用于存储线性表数据元素的存储空间。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。个数据元素的顺序存储的线性表，并将其初始状态设置为。的数据元素，返回该数据元素的编号。获取线性表当前长度：获取并返回线性表的当前长度。
数据结构入门——顺序表（SeqList）详解（初始化、增、删、查、改）
ZHA_123的博客
11-01 3275
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。本篇博客我们主要介绍一下顺序表的内容，最后会给出顺序表的应用，也就是之前拖了大家很久的通讯录动态版。
线性表的基本操作实现 - 链表与顺序表
Daioo 随笔
05-14 3999
注：实验用书为 数据结构 C语言版 第2版，人民邮电出版社出版。 一、实验目的 1、掌握线性表的定义； 2、掌握线性表的基本操作，如建立、查找、插入和删除等。 二、实验内容 定义一个包含学生信息（学号，姓名，成绩）的顺序表和链表，使其具有如下功能： 1、根据指定学生个数，逐个输入学生信息; 2、逐个显示学生表中所有学生的相关信息; 3、根据姓名进行查找，返回此学生的学号和成绩; 4
【头歌】单链表的基本操作
qq_39977056的博客
01-23 1万+
由于单链表中每个结点的存储地址是存放在其前趋结点的指针域中的，而第一个结点无前趋，头指针L指向第一个结点，对于整个单链表的读取必须从头指针开始，同时，由于单链表中最后一个结点的指针域为“空”（NULL），没有直接后继元素，对于整个单链表的读取必须在尾结点结束。要在带头结点的单链表L中删除第i个结点，则同样要先找到第i-1个结点，使p指向第i-1个结点，使q指向第i个结点，然后令第i-1个结点的指针域指向第i+1个结点，而后删除q指向的第i个结点并释放结点空间。= NULL时，才能进行删除结点的操作。
顺序表相关操作实现
qq_31239371的博客
05-12 369
/*顺序表的相关定义及操作，重点掌握查找，插入以及删除操作及其时间复杂度*/ #include <stdio.h> #include <stdlib.h> #include <math.h> #include <iostream> using namespace std; #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define.
c语言请利用两个栈s1和s2来模拟一个队列,考研数据结构之队列（3.3）——练习题之利用两个栈s1和s2来模拟一个队列，然后利用栈的运算来实现队列的enQueue、deQueue及isQueueEmp...
weixin_42497633的博客
05-20 913
题目请利用两个栈sI和s2来模拟-一个队列，假设栈中元素为int型，栈中元素最多为maxSize。己知栈的3个运算定义如下。push(ST,x):元素x入ST栈。pop(ST,&x):ST栈顶元素出栈，赋给变量X。isEmpty(ST):判断ST栈是否为空。如何利用栈的运算来实现该队列的3个运算:enQueue(元素入队列)、deQueue(元素出队列)、isQueueEmpty...
educoderC语言平台实训答案【添加结构体+文件部分】（仅供参考）
热门推荐
qq_44737028的博客
06-25 3万+
第2部分顺序结构程序设计 第1关： 加法运算 任务描述 本关任务：写一个加法程序，输入整数a,b，输出他们的和。 相关知识（略） 编程要求 请补充Begin-End之间的代码，写一个加法程序，输入整数a,b，输出他们的和。 为避免出现格式错误，请直接拷贝粘贴题目中给的格式字符串和提示信息到你的程序中。 输入格式：scanf("%d,%d",&a,&b); 输出格式：printf("%d+%d=%d\n",a,b,c); 测试说明 平台会对你编写的代码进行测试，若是与预期输出相同，则算通关。
谭浩强C语言数据结构(“关键字”文档)共94张.pptx
11-15
在描述中提到了两种数据结构类型——线性表，包括静态线性表和动态线性表。线性表是一种最基本的数据结构，其中元素按照线性的顺序排列。静态线性表通常在内存中连续存储，大小固定，适用于元素数量预先知道的情况。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值