数据结构 顺序表

头

#include <stdio.h>

#define ElemType int
// 定义顺序表里存储的数据类型
#define MAXSIZE 100
// 定义顺序表的长度

定义顺序表

typedef struct
{
    ElemType elem[MAXSIZE];
    int length;
    int listsize;
} SeqList;

1.初始化顺序表

int InitList(SeqList *L)
{
    if (!L->elem)
    {
        return 0;
    }
    L->length = 0;
    L->listsize = MAXSIZE;
    return 1;
}

2.销毁顺序表

int DestroyList(SeqList *L)
{
    if (!L->elem)
    {
        return 0;
    }
    L->length = 0;
    L->listsize = 0;
    return 1;
}

3.清空顺序表

int ClearList(SeqList *L)
{
    for (int i = 0; i < L->length; i++)
    {
        L->elem[i] = 0;
    }
    L->length = 0;
    return 1;
}

4.判断顺序表是否为空

int ListEmpty(SeqList *L)
{
    return L->length == 0;
}

5.获取顺序表的长度

int ListLength(SeqList *L)
{
    return L->length;
}

6.获取顺序表中第i个元素

int GetElem(SeqList *L, int i)
{
    if (i < 1 || i > L->length)
    {
        return 0;
    }
    return L->elem[i - 1];
}

7.查找顺序表中元素e的位置

int Locate(SeqList *L, ElemType e)
{
    for (int i = 0; i < L->length; i++)
    {
        if (L->elem[i] == e)
        {
            return i + 1;
        }
    }
    return 0;
}

8.在顺序表L的第i个位置插入元素e

int ListInsert(SeqList *L, int i, ElemType e)
{
    if (i < 1 || i > L->length + 1)
    {
        return 0;
    }
    if (L->length >= L->listsize)
    {
        return 0;
    }
    for (int j = L->length; j >= i; j--)
    {
        L->elem[j] = L->elem[j - 1];
    }
    L->elem[i - 1] = e;
    L->length++;
    return 1;
}

9.删除顺序表L的第i个元素

int ListDelete(SeqList *L, int i)
{
    if (i < 1 || i > L->length)
    {
        return 0;
    }
    for (int j = i; j <= L->length; j++)
    {
        L->elem[j - 1] = L->elem[j];
    }
    L->length--;
    return 1;
}

10.获取顺序表中第i个元素的前驱元素

int PriorElem(SeqList *L, int i)
{
    if (i < 2 || i > L->length)
    {
        return 0;
    }
    return L->elem[i - 2];
}

11.获取顺序表中第i个元素的后继元素

int NextElem(SeqList *L, int i)
{
    if (i < 1 || i >= L->length)
    {
        return 0;
    }
    return L->elem[i];
}

12.修改顺序表元素e的值

int Modify(SeqList *L, int i, ElemType e)
{
    if (i < 1 || i > L->length)
    {
        return 0;
    }
    L->elem[i - 1] = e;
    return 1;
}

#include <stdio.h>

#define ElemType int
#define MAXSIZE 100

typedef struct
{
    ElemType elem[MAXSIZE];
    int length;
    int listsize;
} SeqList;

/* 1.初始化顺序表 */
int InitList(SeqList *L)
{
    if (!L->elem)
    {
        return 0;
    }
    L->length = 0;
    L->listsize = MAXSIZE;
    return 1;
}

/* 2.销毁顺序表 */
int DestroyList(SeqList *L)
{
    if (!L->elem)
    {
        return 0;
    }
    L->length = 0;
    L->listsize = 0;
    return 1;
}

/* 3.清空顺序表 */
int ClearList(SeqList *L)
{
    for (int i = 0; i < L->length; i++)
    {
        L->elem[i] = 0;
    }
    L->length = 0;
    return 1;
}

/* 4.判断顺序表是否为空 */
int ListEmpty(SeqList *L)
{
    return L->length == 0;
}

/* 5.获取顺序表的长度 */
int ListLength(SeqList *L)
{
    return L->length;
}

/* 6.获取顺序表中第i个元素 */
int GetElem(SeqList *L, int i)
{
    if (i < 1 || i > L->length)
    {
        return 0;
    }
    return L->elem[i - 1];
}

/* 7.查找顺序表中元素e的位置 */
int Locate(SeqList *L, ElemType e)
{
    for (int i = 0; i < L->length; i++)
    {
        if (L->elem[i] == e)
        {
            return i + 1;
        }
    }
    return 0;
}

/* 8.在顺序表L的第i个位置插入元素e */
int ListInsert(SeqList *L, int i, ElemType e)
{
    if (i < 1 || i > L->length + 1)
    {
        return 0;
    }
    if (L->length >= L->listsize)
    {
        return 0;
    }
    for (int j = L->length; j >= i; j--)
    {
        L->elem[j] = L->elem[j - 1];
    }
    L->elem[i - 1] = e;
    L->length++;
    return 1;
}

/* 9.删除顺序表L的第i个元素 */
int ListDelete(SeqList *L, int i)
{
    if (i < 1 || i > L->length)
    {
        return 0;
    }
    for (int j = i; j <= L->length; j++)
    {
        L->elem[j - 1] = L->elem[j];
    }
    L->length--;
    return 1;
}

/* 10.获取顺序表中第i个元素的前驱元素 */
int PriorElem(SeqList *L, int i)
{
    if (i < 2 || i > L->length)
    {
        return 0;
    }
    return L->elem[i - 2];
}

/* 11.获取顺序表中第i个元素的后继元素 */
int NextElem(SeqList *L, int i)
{
    if (i < 1 || i >= L->length)
    {
        return 0;
    }
    return L->elem[i];
}

/* 12.修改顺序表元素e的值 */
int Modify(SeqList *L, int i, ElemType e)
{
    if (i < 1 || i > L->length)
    {
        return 0;
    }
    L->elem[i - 1] = e;
    return 1;
}

int main()
{
    SeqList L;
    InitList(&L);                    // 初始化顺序表
    printf("%d\n", ListLength(&L));  // 输出顺序表的长度
    printf("----------\n");          // 输出分隔符
    ListInsert(&L, 1, 100);          // 在顺序表L的第1个位置插入元素100
    printf("%d ", ListLength(&L));   // 输出顺序表的长度
    printf("%d ", GetElem(&L, 1));   // 输出顺序表的第一个元素
    printf("%d\n", Locate(&L, 100)); // 查找顺序表中元素100的位置
    printf("----------\n");          // 输出分隔符
    ListInsert(&L, 2, 200);          // 在顺序表L的第2个位置插入元素200
    printf("%d ", ListLength(&L));   // 输出顺序表的长度
    printf("%d ", GetElem(&L, 2));   // 输出顺序表的第二个元素
    printf("%d\n", Locate(&L, 200)); // 查找顺序表中元素200的位置
    printf("----------\n");          // 输出分隔符
    ListDelete(&L, 2);               // 删除顺序表L的第2个元素
    printf("%d ", ListLength(&L));   // 输出顺序表的长度
    printf("%d ", GetElem(&L, 2));   // 输出顺序表的第二个元素
    printf("%d\n", Locate(&L, 200)); // 查找顺序表中元素200的位置
    printf("----------\n");          // 输出分隔符
    ListInsert(&L, 2, 200);          // 在顺序表L的第2个位置插入元素200
    Modify(&L, 1, 300);              // 修改顺序表元素100的值为300
    printf("%d ", ListLength(&L));   // 输出顺序表的长度
    printf("%d ", GetElem(&L, 1));   // 输出顺序表的第一个元素
    printf("%d\n", Locate(&L, 300)); // 查找顺序表中元素300的位置
    printf("----------\n");          // 输出分隔符
    ClearList(&L);                   // 清空顺序表
    printf("%d\n", ListLength(&L));  // 输出顺序表的长度
    printf("----------\n");          // 输出分隔符
    ListInsert(&L, 1, 100);          // 在顺序表L的第1个位置插入元素100
    ListInsert(&L, 2, 200);          // 在顺序表L的第2个位置插入元素200
    ListInsert(&L, 3, 300);          // 在顺序表L的第3个位置插入元素300
    printf("%d ", PriorElem(&L, 2)); // 获取顺序表中第2个元素的前驱元素
    printf("%d\n", NextElem(&L, 2)); // 获取顺序表中第2个元素的后继元素
    printf("----------\n");          // 输出分隔符
    DestroyList(&L);                 // 销毁顺序表
    printf("%d\n", ListLength(&L));  // 输出顺序表的长度
    return 0;
}