顺序表的基本操作

/**
 * @file SequenceList.cpp
 * @author qq_45671732 (2324144691@qq.com)
 * @brief
 * @version 0.1
 * @date 2022-08-16
 *
 * @copyright Copyright (c) 2022
 *
 */
#include "iostream"

using namespace std;

//顺序表允许的最大的表长
#define MAXSIZE 100

#define TRUE 1

#define FALSE 0

//函数操作执行成功返回OK
#define OK 1

//函数操作执行失败返回ERROR
#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2

typedef int Status;

typedef string ElemType;

/*
SqList结构体有两个成员:
ElemType* elem 是指向代表顺序表的数组的首地址
int length顺序表的表长
*/
typedef struct
{
    ElemType* elem;
    int length;
} SqList;


Status SqList_Init(SqList& L);

Status SqList_Destroy(SqList& L);

Status SqList_Clear(SqList& L);

Status SqList_IsEmpty(SqList L);

int SqList_Length(SqList L);

Status SqList_GetElem(SqList L, int i, ElemType& e);

Status SqList_Insert(SqList& L, int i, ElemType e);

Status SqList_Delete(SqList& L, int i);

Status SqList_Ergodic(SqList L);

int SqList_LocateElem(SqList L, ElemType e);

int main()
{
    SqList sqlist;
    //在进行顺序表的许多操作时必须保证内存中已经存在顺序表
    SqList_Init(sqlist);
    int choose;
    do
    {
        std::cout << "1.顺序表销毁" << std::endl;
        std::cout << "2.顺序表清空" << std::endl;
        std::cout << "3.顺序表判空" << std::endl;
        std::cout << "4.顺序表长" << std::endl;
        std::cout << "5.在顺序表中查找位序为i对应的内容" << std::endl;
        std::cout << "6.顺序表插入" << std::endl;
        std::cout << "7.顺序表删除" << std::endl;
        std::cout << "8.顺序表遍历" << std::endl;
        std::cout << "9.在顺序表中查找内容为e对应的位序" << std::endl;
        cout << "请输入您的选择" << endl;
        cin >> choose;
        switch (choose)
        {
            case 1:
            {
                SqList_Destroy(sqlist);
                break;
            }
            case 2:
            {
                SqList_Clear(sqlist);
                break;
            }
            case 3:
            {
                SqList_IsEmpty(sqlist);
                break;
            }
            case 4:
            {
                int length = SqList_Length(sqlist);
                cout << "顺序表的表长为:" << length << endl;
                break;
            }
            case 5:
            {
                int i;
                cout << "请输入i的值" << endl;
                cin >> i;
                ElemType e;
                SqList_GetElem(sqlist, i, e);
                cout << "位序为" << i << "上存放的内容是:" << e << endl;
                break;
            }
            case 6:
            {
                int i;
                ElemType e;
                cout << "请输入您要插入的元素的值" << endl;
                cin >> e;
                cout << "请输入您要插入的位序" << endl;
                cin >> i;
                SqList_Insert(sqlist, i, e);
                break;
            }
            case 7:
            {
                int i;
                cout << "请输入您要删除元素的位序" << endl;
                cin >> i;
                SqList_Delete(sqlist, i);
                break;
            }
            case 8:
            {
                SqList_Ergodic(sqlist);
                break;
            }
            case 9:
            {
                ElemType e;
                cout << "请输入您要查找的内容:" << endl;
                cin >> e;
                int i = SqList_LocateElem(sqlist, e);
                cout << "内容为:" << e << "的元素存放在位序为:" << i  << "的地方" << endl;
                break;
            }
            default:
            {
                //默认退出
                exit(ERROR);
            }
        }
    } while (1);
    system("pause");
    return 0;
}

Status SqList_Init(SqList& L)
{
    /*
    顺序表初始化
    */
    //给顺序表的数组分配MAXSIZE个ElemType类型的空间
    L.elem = new ElemType[MAXSIZE];//使用C++中的new关键字初始化顺序表的内存空间并返回顺序表在内存的首地址给指针elem
    //在C语言中为L.elem = (ElemType *)malloc(sizeof(ElemType) * MAXSIZE); 
    //malloc()函数中的形参为要申请的内存空间的大小 在顺序表中需要去申请一块(sizeof(ElemType) * MAXSIZE)大的空间，并用(ElemType *)将刚刚申请的空间转换成每一个大小为sizeof(ElemType)的小空间 用L.elem接收返回空间的首地址
    if (L.elem != NULL)
    {
        //顺序表的数组内存分配成功
        std::cout << "顺序表初始化成功!" << std::endl;
        //顺序表的长度设置为0
        L.length = 0;
        return OK;
    }
    else
    {
        //顺序表初始化失败 返回ERROR
        std::cerr << "ERROR" << std::endl;
        return ERROR;
    }
}

Status SqList_Destroy(SqList& L)
{
    if (L.elem != NULL)
    {
        //如果顺序表的数组的首地址不为NULL 则进行销毁操作
        std::cout << "顺序表销毁成功!" << std::endl;
        //如果数组是用new关键字申请的内存 则需要使用(delete 指针;)的方式将指针指向的内存空间释放掉
        //如果数组是用malloc函数申请的内存 则需要使用(free(指针);)的方式将指针指向的内存空间释放掉
        delete L.elem;
        //C语言中为free(L.elem);
    }
    return OK;
}

Status SqList_Clear(SqList& L)
{
    //进行逻辑清空即可，顺序表再次存放数据时 会对原来的数据进行覆盖操作
    if (L.length != 0)
    {
        L.length = 0;
    }
    cout << "顺序表清空成功!" << endl;
    return OK;
}

Status SqList_Insert(SqList& L, int i, ElemType e)
{
    //在位序i上插入e
    if ((i < 1) || (i > L.length + 1))
    {
        //在顺序表中允许插入的位序为 (1 ~ L.length + 1)
        cout << "ERROR" << endl;
        return ERROR;
    }
    if (L.length >= MAXSIZE)
    {
        //顺序表已经满了 也可以用realloc为数组划分更大的存储空间
        cout << "ERROR" << endl;
        return ERROR;
    }
    for (int j = L.length - 1; j >= i - 1; j--)
    {
        //顺序表中最后一个元素存储在下标为(L.length - 1)的存储单元中，位序为i的元素存储在下标为(i - 1)的存储单元中
        //做一个简单的后移操作
        L.elem[j + 1] = L.elem[j];
    }
    //将元素e放置在(i - 1)的存储空间
    L.elem[i - 1] = e;
    //顺序表的长度自增1
    L.length++;
    cout << "顺序表插入成功!" << endl;
    return OK;
}

Status SqList_Delete(SqList& L, int i)
{
    //位序为i 只可以删除位序为1 ～ L.length的元素
    if ((i < 1) || (i > L.length))
    {
        // i的位置不合法
        cout << "ERROR" << endl;
        return ERROR;
    }
    //位序为i合法后，删除位序为i 也就是下标为(i - 1)的元素
    for (int j = i; j <= L.length - 1; j++)
    {
        //删除位序为i的元素 也就是将位序为(i + 1)的元素 一直到 位序为n的元素依次向前移动
        //而位序为(i + 1)的元素存放在下标为i的位置 位序为n的元素存放在下标为(L.length - 1)的位置
        L.elem[j - 1] = L.elem[j];
    }
    //顺序表长减1
    L.length--;
    cout << "顺序表删除成功" << endl;
    return OK;
}

Status SqList_IsEmpty(SqList L)
{
    /*
    顺序表判空 
    如果顺序表的表长不为0 则说明有数据
    如果顺序表的表长为0 则说明为空
    */
    if (L.length != 0)
    {
        cout << "顺序表不为空!" << endl;
    }
    else
    {
        cout << "顺序表为空!" << endl;
    }
    return OK;
}

int SqList_Length(SqList L)
{
    //直接用return返回顺序表的表长即可
    return L.length;
}

Status SqList_Ergodic(SqList L)
{
    //顺序表遍历
    cout << "**************************" << endl;
    for (int i = 0; i < L.length; i++)
    {
        cout << L.elem[i] << " ";
    }
    cout << endl;
    cout << "**************************" << endl;
    cout << "顺序表遍历完成" << endl;
    return OK;
}

int SqList_LocateElem(SqList L, ElemType e)
{
    //获取元素e的位序
    for (int j = 0; j < L.length; j++)
    {
        //将顺序表从头开始遍历 如果L.elem[j] == e 则返回(j + 1) (j为数组的下标 j + 1为位序)
        if (L.elem[j] == e)
        {
            return j + 1;
        }
    }
    return OK;
}

Status SqList_GetElem(SqList L, int i, ElemType& e)
{
    //将线性表L中位序为i的元素返回给e
    if ((i > L.length) || (i < 1))
    {
        /*
        异常处理
        当(i > L.length) 或者是 (i < 1) 返回ERROR
        */
        cout << "ERROR" << endl;
        return ERROR;
    }
    else
    {
        //将顺序表位序为i也就是下标为i-1上的元素赋值给e
        e = L.elem[i - 1];
        cout << "OK" << endl;
        return OK;
    }
}