＜第1章 第1章 作业1: 第一题： 编程实现线性表顺序存储下的基本操作： 1．初始化2．插入元素 3．删除元素 4．获取第复制搜索 5．判断元素是否存在﹣-﹣前面5个已提供源码参考 6．获取某个元素的下一个元素； NextElem ( L , cur _ e ,& next _ e );加架 7．获取某个元素的前一个元素； PriorElem ( L , cur _ e .& pre e ): 21:21 1/347.62%

next _ e )
{
if (cur_e < 1 || cur_e >= L.length) // 判断当前元素是否在表中
{
return ERROR;
}

if (cur_e == L.length - 1) // 若当前元素为最后一个元素，则无下一个元素
{
return ERROR;
}

next_e = L.data[cur_e + 1]; // 获取下一个元素
return OK;
}

相关问题

编程实现线性表顺序存储下的基本操作： 1.初始化 2.插入元素 3.删除元素 4.获取第i个元素 5.判断元素是否存在---前面5个已提供源码参考 6.获取某个元素的下一个元素；; 7.获取某个元素的前一个元素；);C语言

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 100 // 线性表的最大长度

typedef struct {
int *data; // 存储元素的数组
int length; // 线性表的当前长度
} SeqList;

// 初始化线性表
void init(SeqList *L) {
L->data = (int *)malloc(MAXSIZE * sizeof(int)); // 动态分配存储空间
L->length = 0;
}

// 插入元素
int insert(SeqList *L, int i, int e) {
if (i < 1 || i > L->length + 1) { // 判断 i 的范围是否合法
return 0;
}
if (L->length >= MAXSIZE) { // 判断线性表是否已满
return 0;
}
for (int j = L->length; j >= i; j--) {
L->data[j] = L->data[j - 1]; // 将元素后移
}
L->data[i - 1] = e; // 插入新元素
L->length++; // 线性表长度加 1
return 1;
}

// 删除元素
int del(SeqList *L, int i) {
if (i < 1 || i > L->length) { // 判断 i 的范围是否合法
return 0;
}
for (int j = i; j < L->length; j++) {
L->data[j - 1] = L->data[j]; // 将元素前移
}
L->length--; // 线性表长度减 1
return 1;
}

// 获取第 i 个元素
int get(SeqList *L, int i) {
if (i < 1 || i > L->length) { // 判断 i 的范围是否合法
return -1;
}
return L->data[i - 1];
}

// 判断元素是否存在
int find(SeqList *L, int e) {
for (int i = 0; i < L->length; i++) {
if (L->data[i] == e) {
return 1;
}
}
return 0;
}

// 获取某个元素的下一个元素
int getNext(SeqList *L, int e) {
for (int i = 0; i < L->length - 1; i++) {
if (L->data[i] == e) {
return L->data[i + 1];
}
}
return -1; // 没有找到该元素或该元素为线性表的最后一个元素
}

// 获取某个元素的前一个元素
int getPrev(SeqList *L, int e) {
for (int i = 1; i < L->length; i++) {
if (L->data[i] == e) {
return L->data[i - 1];
}
}
return -1; // 没有找到该元素或该元素为线性表的第一个元素
}

int main() {
SeqList L;
init(&L);
for (int i = 1; i <= 5; i++) {
insert(&L, i, i);
}
printf("插入前：\n");
for (int i = 1; i <= L.length; i++) {
printf("%d ", get(&L, i));
}
printf("\n");
insert(&L, 3, 10);
printf("在第 3 个位置插入 10 后：\n");
for (int i = 1; i <= L.length; i++) {
printf("%d ", get(&L, i));
}
printf("\n");
del(&L, 4);
printf("删除第 4 个元素后：\n");
for (int i = 1; i <= L.length; i++) {
printf("%d ", get(&L, i));
}
printf("\n");
if (find(&L, 3)) {
printf("元素 3 存在\n");
} else {
printf("元素 3 不存在\n");
}
if (find(&L, 6)) {
printf("元素 6 存在\n");
} else {
printf("元素 6 不存在\n");
}
int next = getNext(&L, 3);
if (next != -1) {
printf("元素 3 的下一个元素是 %d\n", next);
} else {
printf("元素 3 没有下一个元素或不存在\n");
}
int prev = getPrev(&L, 5);
if (prev != -1) {
printf("元素 5 的前一个元素是 %d\n", prev);
} else {
printf("元素 5 没有前一个元素或不存在\n");
}
return 0;
}

编程实现线性表顺序存储下的基本操作 1.初始化 2.插入元素 3.删除元素 4.获取第i人元素 5.判断元素是否存在---前面5个已提供源码参考 6.获取某个元素的下一个元素; NextElem(L，cur_e，&next_e);7.获取某个元素的前一个元素; PriorElem(L，cur_e，&pre_e);

1.初始化操作：

typedef struct {
ElemType *elem; // 存储空间基址
int length; // 当前长度
int listsize; // 分配的存储容量
} SqList;

// 初始化线性表
Status InitList(SqList *L) {
L->elem = (ElemType *) malloc(LIST_INIT_SIZE * sizeof(ElemType));
if (!L->elem) exit(OVERFLOW); // 存储分配失败
L->length = 0; // 空表长度为0
L->listsize = LIST_INIT_SIZE; // 初始存储容量
return OK;
}

2.插入元素操作：

// 在顺序线性表L中第i个位置之前插入新的元素e
Status ListInsert(SqList *L, int i, ElemType e) {
if (i < 1 || i > L->length + 1) return ERROR; // i值不合法
if (L->length >= L->listsize) { // 当前存储空间已满，增加分配
ElemType *newbase = (ElemType *) realloc(L->elem, (L->listsize + LISTINCREMENT) * sizeof(ElemType));
if (!newbase) exit(OVERFLOW); // 存储分配失败
L->elem = newbase; // 新基址
L->listsize += LISTINCREMENT; // 增加存储容量
}
ElemType *q = &(L->elem[i - 1]); // q为插入位置
for (ElemType *p = &(L->elem[L->length - 1]); p >= q; --p) *(p + 1) = *p; // 插入位置及之后的元素后移
*q = e; // 插入e
++L->length; // 表长增1
return OK;
}

3.删除元素操作：

// 删除顺序线性表L中第i个位置的元素，并用e返回其值
Status ListDelete(SqList *L, int i, ElemType *e) {
if (i < 1 || i > L->length) return ERROR; // i值不合法
ElemType *p = &(L->elem[i - 1]); // p为被删除元素的位置
*e = *p; // 被删除元素的值赋给e
ElemType *q = L->elem + L->length - 1; // 表尾元素位置
for (++p; p <= q; ++p) *(p - 1) = *p; // 被删除元素之后的元素前移
--L->length; // 表长减1
return OK;
}

4.获取第i个元素操作：

// 获取顺序线性表L中第i个元素的值
Status GetElem(SqList L, int i, ElemType *e) {
if (i < 1 || i > L.length) return ERROR; // i值不合法
*e = L.elem[i - 1]; // 取第i个元素
return OK;
}

5.判断元素是否存在操作：

// 在顺序线性表L中查找第1个值为e的元素，并返回其位序
int LocateElem(SqList L, ElemType e) {
int i;
ElemType *p = L.elem;
for (i = 1; i <= L.length; ++i) {
if (*p++ == e) return i; // 找到值为e的元素
}
return 0; // 没有找到值为e的元素
}

6.获取某个元素的下一个元素操作：

// 获取顺序线性表L中元素cur_e的下一个元素的值
Status NextElem(SqList L, ElemType cur_e, ElemType *next_e) {
int i = LocateElem(L, cur_e); // 查找cur_e的位置
if (i == 0 || i == L.length) return ERROR; // 没有找到cur_e或者cur_e是最后一个元素
*next_e = L.elem[i]; // 取cur_e的下一个元素
return OK;
}

以上是线性表顺序存储下的基本操作的实现代码。