hnust 1949: 顺序表实现(第二部分)

题目描述

拷贝下面的代码，然后将顺序表实现第一部分的工作填入，再完成顺序表的GetElem，LocateElem和ListDelete操作，其他地方不得改动。
#include
#include
#include
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status; //Status 是函数返回值类型，其值是函数结果状态代码。

typedef int ElemType; //ElemType 为可定义的数据类型，此设为int类型

#define MAXSIZE 100 //顺序表可能达到的最大长度

typedef struct {
ElemType *elem; //存储空间的基地址
int length; //当前长度
} SqList;

Status InitList(SqList &L) //算法2.1 顺序表的初始化
{
//构造一个空的顺序表L
L.elem = new ElemType[MAXSIZE]; //为顺序表分配一个大小为MAXSIZE的数组空间
if(!L.elem)
exit(OVERFLOW); //存储分配失败退出
L.length = 0; //空表长度为0
return OK;
}
void DestroyList(SqList &L)
{
if(L.elem)
delete []L.elem; //释放存储空间
}

int ListLength(SqList L)
{
/在此下面完成代码***********/

/************************/
}
bool ListEmpty(SqList L)
{
/在此下面完成代码/

/************************/
}
Status GetElem(SqList L, int i, ElemType & e) //算法2.2 顺序表的取值
{
/在此下面完成代码/

/************************/
}
int LocateElem(SqList L, ElemType e) //算法2.3 顺序表的查找
{
/在此下面完成代码/

/************************/
}
Status ListInsert(SqList & L, int i, ElemType e) //算法2.4 顺序表的插入
{
/在此下面完成代码/

/************************/
}
Status ListDelete(SqList & L, int i) //算法2.5 顺序表的删除
{
/在此下面完成代码/

/***********************************/
}
void ListPrint(SqList L)
{
for(int i = 0; i < L.length; i++)
cout << L.elem[i] << ((i == L.length - 1) ? ‘\n’ : ’ ');
}
int main()
{
int i;
ElemType e;
SqList L;
string op;
InitList(L);
while(cin >> op) {
if(op == “Empty”)
cout << (ListEmpty(L) ? “Empty” : “Not empty”) << endl;
else if(op == “Insert”) {
cin >> i >> e;
if(ListInsert(L, i, e) == ERROR)
cout << “Insert failed” << endl;
else
ListPrint(L);
} else if(op == “Length”) {
cout << "List length is " << ListLength(L) << endl;
} else if(op == “GetElem”) {
cin >> i;
if(GetElem(L, i, e) == ERROR)
cout << “Out of index” << endl;
else
cout << “The elem at position " << i << " is " << e << endl;
} else if(op == “LocateElem”) {
cin >> e;
i = LocateElem(L, e);
if(i == 0)
cout << e << " is not found in list” << endl;
else
cout << e << " is found at the position " << i << endl;
} else if(op == “Delete”) {
cin >> i;
if(ListDelete(L, i) == ERROR)
cout << “Delete failed” << endl;
else
ListPrint(L);
}
}
DestroyList(L);
return 0;
}

输入
为线性表的操作系列，每个操作一行，具体见样例。
输出
如果输入为"Empty"， 则根据表是否为空输出"Empty"或 “Not empty”。
如果输入为"Length"，则输出表长。
如果输入为"Insert i e"，插入失败则输出"Insert failed"，否则在i位置插入e后输出插入后表中的所有元素。
如果输入为"GetElem i “，参数i错误输出"Out of index”，否则输出在i位置的元素。
如果输入为"LocateElem e"，如果未发现输出"e is not found in list"，否则输出e在表中第一次出现的位置。
如果输入为"Delete i"，如果失败输出"Delete failed"，否则删除i位置的元素后输出插入后表中的所有元素。
具体参见样例。
样例输入 Copy
Empty
Insert 1 7
Empty
Insert 2 3
Length
Insert 1 -100
Length
Insert 10 100
Length
Insert 2 10000
Empty
GetElem 2
GetElem 5
LocateElem 999
LocateElem 3
Delete 0
Delete 4
Delete 1
Length
样例输出 Copy
Empty
7
Not empty
7 3
List length is 2
-100 7 3
List length is 3
Insert failed
List length is 3
-100 10000 7 3
Not empty
The elem at position 2 is 10000
Out of index
999 is not found in list
3 is found at the position 4
Delete failed
-100 10000 7
10000 7
List length is 2

解题过程

这段C++代码实现了一个基于顺序表的动态数组数据结构，提供了一系列的操作，包括初始化、销毁、检查空、获取长度、插入、删除、查找元素和打印顺序表。以下是对代码的详细解析：

1. 头文件和命名空间：

   • 包含 <iostream>、<cstdio> 和 <cstdlib> 头文件。
   • 使用 using namespace std; 来避免在标准库类型和函数前加 std::。

2. 宏定义：

   • OK、ERROR 和 OVERFLOW 分别定义了操作成功、失败和内存溢出的状态码。

3. 数据类型和结构体定义：

   • Status 用作函数返回值类型，表示操作的状态。
   • ElemType 定义了顺序表中元素的数据类型，这里设为 int。
   • MAXSIZE 定义了顺序表可能达到的最大长度。
   • SqList 结构体定义了顺序表，包含一个指向元素数组的指针 elem 和一个表示当前长度的整数 length。

4. 顺序表初始化函数 InitList：

   • 分配一个大小为 MAXSIZE 的数组空间给顺序表，并初始化长度为0。

5. 顺序表销毁函数 DestroyList：

   • 释放顺序表使用的存储空间。

6. 获取顺序表长度函数 ListLength：

   • 返回顺序表的长度。

7. 检查顺序表是否为空函数 ListEmpty：

   • 如果顺序表长度为0，返回1，表示空；否则返回0，表示非空。

8. 获取元素函数 GetElem：

   • 根据给定的位置 i 获取元素 e。如果位置不合法，返回 ERROR。

9. 查找元素函数 LocateElem：

   • 查找元素 e 在顺序表中的位置，如果找到返回位置加1，否则返回0。

10. 插入元素函数 ListInsert：

    • 在顺序表的指定位置 i 插入元素 e。如果插入位置不合法或存储空间已满，返回 ERROR。

11. 删除元素函数 ListDelete：

    • 删除顺序表中指定位置 i 的元素。如果位置不合法，返回 ERROR。

12. 打印顺序表函数 ListPrint：

    • 遍历顺序表并打印所有元素。

13. 主函数 main：

    • 初始化顺序表。
    • 循环读取操作指令，支持 “Empty”、“Insert”、“Length”、“GetElem”、“LocateElem” 和 “Delete”。
    • 根据指令执行相应操作，并处理可能的错误情况。
    • 销毁顺序表并释放内存。

14. 程序结束：

    • 输入结束后，程序返回0，表示正常结束。

代码逻辑分析：

• 这段代码通过封装一系列操作顺序表的函数，实现了对顺序表的基本操作。
• 使用了动态内存分配和释放，需要注意内存管理以避免内存泄漏。

潜在问题：

• 在 InitList 函数中，如果内存分配失败，则直接 exit(OVERFLOW)，这可能导致程序异常退出。
• ListEmpty 函数返回值与宏定义的状态码不匹配，应返回 OK（非0）表示真，ERROR（0）表示假。

改进建议：

• 考虑使用异常处理来替代 exit 在 InitList 中处理内存分配失败的情况。
• 统一 ListEmpty 函数的返回值，使其与宏定义的状态码一致。
• 在 main 函数中，添加对输入操作的验证，确保它们是预期的指令之一。
• 考虑使用 std::vector 来自动管理内存，简化代码并减少内存管理的复杂性。

---

AC代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status; //Status 是函数返回值类型，其值是函数结果状态代码。typedef int ElemType; //ElemType 为可定义的数据类型，此设为int类型#define MAXSIZE 100 //顺序表可能达到的最大长度typedef struct {ElemType *elem; //存储空间的基地址int length; //当前长度
} SqList;Status InitList(SqList &L)   //算法2.1 顺序表的初始化
{//构造一个空的顺序表LL.elem = new ElemType[MAXSIZE]; //为顺序表分配一个大小为MAXSIZE的数组空间if(!L.elem)exit(OVERFLOW); //存储分配失败退出L.length = 0; //空表长度为0return OK;
}
void DestroyList(SqList &L)
{if(L.elem)delete []L.elem;     //释放存储空间
}int ListLength(SqList L)
{return L.length ;
}
bool ListEmpty(SqList L)
{if(L.length ==0)return 1;else return 0;
}
Status GetElem(SqList L, int i, ElemType & e)   //算法2.2　顺序表的取值
{if(i<1||i>L.length )return ERROR;//判断i值是否合理，若不合理，返回ERROR e=L.elem[i-1];//elem[i-1]单元存储第i个数据元素 return OK;
}
int LocateElem(SqList L, ElemType e)   //算法2.3 顺序表的查找
{for(int i=0;i<L.length ;i++)if(L.elem[i]==e)return i+1;//查找成功，返回序号i+1 return 0; //查找失败，返回0 
}
Status ListInsert(SqList &L, int i, ElemType e)   //算法2.4 顺序表的插入
{/****在此下面完成代码***************/int j;if((i<1)||(i>L.length+1 )){return ERROR;}if (L.length==MAXSIZE) return ERROR;for(j=L.length-1;j>=i-1;j--){L.elem [j+1]=L.elem [j];}L.elem [i-1]=e;++L.length;return OK;/***********************************/
}
Status ListDelete(SqList &L,int i){if(i<1||i>L.length) return ERROR;   //i值不合法for (int j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; //被删除元素之后的元素前移  --L.length;                       //表长减1return OK;
}
void ListPrint(SqList L)
{for(int i = 0; i < L.length; i++)cout << L.elem[i] << ((i == L.length - 1) ? '\n' : ' ');
}
int main()
{int i;ElemType e;SqList L;string op;InitList(L);while(cin >> op) {if(op == "Empty")cout << (ListEmpty(L) ? "Empty" : "Not empty") << endl;else if(op == "Insert") {cin >> i >> e;if(ListInsert(L, i, e) == ERROR)cout << "Insert failed" << endl;elseListPrint(L);} else if(op == "Length") {cout << "List length is " << ListLength(L) << endl;} else if(op == "GetElem") {cin >> i;if(GetElem(L, i, e) == ERROR)cout << "Out of index" << endl;elsecout << "The elem at position " << i << " is " <<  e << endl;} else if(op == "LocateElem") {cin >> e;i = LocateElem(L, e);if(i == 0)cout << e << " is not found in list" << endl;elsecout << e  << " is found at the position " << i << endl;} else if(op == "Delete") {cin >> i;if(ListDelete(L, i) == ERROR)cout << "Delete failed" << endl;elseListPrint(L);}}DestroyList(L);return 0;
}