顺序表的实现

顺序表的实现

本文将介绍一个顺序表的实现，包括创建、插入、删除、查找等操作。

数据结构

首先，我们定义了顺序表的数据结构：

typedef struct {
    ElemType *elem;
    int length;
} SqList;

其中，elem 是一个指向动态分配的数组的指针，length 表示顺序表的当前长度。

初始化顺序表

Status InitList(SqList &L)

这个函数用于初始化一个空的顺序表。它接受一个顺序表的引用作为参数，并分配一个大小为 MAXSIZE 的数组。如果分配成功，函数返回 OK，否则返回 OVERFLOW。

顺序表长度

Status Length(SqList L)

这个函数返回顺序表的当前长度。

销毁顺序表

void DestoryList(SqList &L)

这个函数用于销毁一个顺序表。它接受一个顺序表的引用作为参数，并释放其动态分配的数组。

清空顺序表

void ClearList(SqList &L)

这个函数用于清空一个顺序表。它接受一个顺序表的引用作为参数，并将其长度设置为0。

获取顺序表长度

int GetLength(SqList &L)

这个函数返回顺序表的当前长度。

判断顺序表是否为空

int isEmpty(SqList &L)

这个函数判断一个顺序表是否为空。如果为空，返回1，否则返回0。

获取指定位置的元素

ElemType GetElem(SqList L,int i,ElemType &e)

这个函数用于获取顺序表中指定位置的元素。它接受一个顺序表、一个位置 i 和一个元素的引用作为参数。如果位置有效，函数将该位置的元素赋值给引用，并返回 OK，否则返回 ERROR。

查找元素

int find(SqList L,ElemType &e)

这个函数用于查找顺序表中等于给定元素的第一个元素。它接受一个顺序表和一个元素的引用作为参数。如果找到该元素，函数返回其位置（从1开始计数），否则返回0。

打印顺序表

Status PrintList(SqList L)

这个函数用于打印顺序表中的所有元素。它接受一个顺序表作为参数，并打印其所有元素及其长度。

删除元素

int ListDelete(SqList &L,int i,ElemType &e)

这个函数用于删除顺序表中指定位置的元素。它接受一个顺序表的引用、一个位置 i 和一个元素的引用作为参数。如果位置有效，函数将该位置的元素赋值给引用，并将该位置之后的所有元素向前移动一位，然后将顺序表的长度减1。最后，函数返回被删除的元素。

插入元素

Status ListInsert(SqList &L,int i,ElemType e)

这个函数用于在顺序表的指定位置插入一个元素。它接受一个顺序表的引用、一个位置 i 和一个元素作为参数。如果位置有效，函数将该位置之后的所有元素向后移动一位，然后将新元素插入到指定位置。最后，函数返回 OK。

入栈操作

Status push(SqList &L,ElemType e)

这个函数用于在顺序表的末尾插入一个元素。它接受一个顺序表的引用和一个元素作为参数。函数将新元素插入到顺序表的末尾，并将顺序表的长度加1。最后，函数返回 OK。

主函数

int main()

这是程序的主函数，用于测试顺序表的各种操作。

- 创建一个空的顺序表
- 向顺序表中插入元素
- 打印顺序表
- 删除顺序表中的元素
- 插入新元素
- 判断顺序表是否为空
- 查找元素

这个主函数首先创建一个空的顺序表，然后向其中插入一些元素。接着，它打印顺序表，并尝试删除一些元素。然后，它插入一些新元素，并再次打印顺序表。最后，它判断顺序表是否为空，并查找一个元素。

代码如下:

#include<iostream>
#include<fstream>
using namespace std;

// 定义常量
#define MAXSIZE 100 // 顺序表最大容量
#define ERROR 0 // 错误状态码
#define TRUE 1 // 真状态码
#define FALSE 0 // 假状态码
#define OK 1 // 正确状态码
#define INFEASIBLE -1 // 不可行状态码
#define OVERFLOW -2 // 溢出错误状态码

// 定义元素类型
typedef int ElemType;

// 定义状态类型
typedef int Status;

// 定义顺序表结构体
typedef struct { 
    ElemType *elem; // 存储元素的数组指针
    int length; // 当前顺序表中的元素个数
} SqList;

// 全局变量
int n, m; // 未使用的全局变量
char st = 'A'; // 未使用的全局字符变量

// 初始化顺序表
Status InitList(SqList &L) 
{
    L.elem = new ElemType[MAXSIZE]; // 动态分配内存
    if(!L.elem) exit(OVERFLOW); // 如果内存分配失败，则退出程序
    L.length = 0; // 初始化长度为0
    return OK; // 返回正确状态
}

// 获取顺序表长度
int Length(SqList L) {
    return L.length; // 直接返回顺序表长度
}

// 销毁顺序表，释放内存
void DestoryList(SqList &L) {
    if(L.elem) delete [] L.elem; // 删除动态分配的内存
}

// 清空顺序表，保留内存但清空元素
void ClearList(SqList &L) {
    L.length=0; // 将长度置零
}

// 获取顺序表长度的另一种实现
int GetLength(SqList &L) {
    return L.length;
}

// 判断顺序表是否为空
int isEmpty(SqList &L) {
    if(L.length==0) return 1; // 长度为0则为空
    else return 0; // 非0则不为空
}

// 获取顺序表中第i个元素
Status GetElem(SqList L, int i, ElemType &e) 
{
    if(i<1||i>L.length) { // 非法索引
        return ERROR;
    }
    e=L.elem[i-1]; // 获取指定索引处的元素
    return OK; // 成功获取元素
}

// 查找等于e的元素的索引位置
int find(SqList L, ElemType &e) 
{
    for(int i=0; i<L.length; i++) {
        if(L.elem[i]==e) {
            return i; // 找到元素，返回索引
        }
    }
    return 0; // 没有找到返回0
}

// 打印顺序表内容
Status PrintList(SqList L) 
{
    for(int i=0; i<L.length; i++) {
        cout<<"the"<<i+1<<"th element is:"<<L.elem[i]<<endl;
    }
    cout<<"the list's length is:"<<L.length<<endl;
    return OK;
}

// 删除顺序表中第i个元素并返回该元素
int ListDelete(SqList &L, int i, ElemType &e) 
{
    if(L.length==0) {
        return ERROR; // 空表不能删除元素
    }
    if(i<0||i>L.length) {
        return ERROR; // 非法索引
    }
    e=L.elem[i-1]; // 保存待删除元素

    // 将删除点后面的元素向前移动一位
    for(int j=i; j<L.length; j++) {
        L.elem[j-1]=L.elem[j];
    }
    L.length--; // 长度减1
    return e; // 返回已删除的元素
}

// 插入元素e到顺序表的第i个位置
Status ListInsert(SqList &L, int i, ElemType e) 
{
    if(L.length==MAXSIZE) return ERROR; // 表满无法插入
    if(i<0||i>L.length) return ERROR; // 非法索引
    if(i<L.length) {
        // 将插入点及其后面的所有元素向后移动一位
        for (int j = L.length - 1; j >= i-1; --j) {
            L.elem[j+1]=L.elem[j];
        }
    }
    L.elem[i-1]=e; // 插入新元素
    L.length++; // 长度加1

    return OK; // 插入成功
}

// 在顺序表尾部压入元素
Status push(SqList &L, ElemType e) 
{
    L.elem[L.length]=e; // 直接将元素放入尾部
    L.length++; // 长度加1
    return OK;
}

int main() 
{
    SqList list; // 创建顺序表对象
    InitList(list); // 初始化顺序表
    push(list,1); // 在尾部压入元素1
    push(list,12);
    push(list,123);
    push(list,1234);
    push(list,12345);
    push(list,123456);
    
    // 打印初始顺序表
    PrintList(list);

    // 删除操作试例
    ElemType tmp;
    cout<<"Deleted element is: "<<ListDelete(list,6,tmp)<<endl;
    cout<<"Deleted element is: "<<ListDelete(list,2,tmp)<<endl;
    cout<<"Deleted element is: "<<ListDelete(list,1,tmp)<<endl;

    // 再次打印顺序表
    PrintList(list);

    // 插入操作实例
    ListInsert(list,1,123456789);
    ListInsert(list,3,98);

    // 再次打印顺序表
    PrintList(list);

    // 测试是否为空
    cout<<isEmpty(list)<<endl;

    // 测试查找元素功能
    tmp=98;
    cout<<tmp<<" is at the "<<find(list,tmp)+1<<"th position."<<endl;

    return 0;
}