<线性表>顺序表

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

#define MAXSIZE 100

#define Elemtype int
#define Staues int

#define OVERFLOW -2
#define ERROR -1
#define OK 0
#define TRUE 1
#define FALSE 0

// 数据结构定义
typedef struct 
{
    Elemtype *elem;
    int length;
}SqList;

// 构造一个空的顺序表
Staues InitList(SqList *L)
{
    L->elem = (Elemtype *)malloc(sizeof(Elemtype) * MAXSIZE);
    if(!L->elem)
        exit(OVERFLOW);
    L->length = 0;
    return OK;
}

// 顺序表的取值 T(1)
Staues GetElem(SqList L,int i,Elemtype *e)
{
    if (i < 1 || i > L.length)
        return ERROR;
    *e = L.elem[i-1];
    return OK;
}

// 顺序表的查找 在顺序表L中查找值为e的数据元素，返回其序号 T(n)
int LocateElem(SqList L,Elemtype e)
{
    for (int  i = 0; i < L.length; i++)
    {
        if(L.elem[i] == e) 
            return i+1;
    }
    return 0;  
}

// 在顺序表L中第i个位置之前插入新的元素e  i 合法范围 1 <= i <= L.length + 1 T(n)
Staues ListInsert(SqList *L,int i,Elemtype e)
{
    if(i < 1 || i > L->length + 1)
        return ERROR;
    if(L->length == MAXSIZE)
        return ERROR;
    for(int j = L->length-1;j>=i-1;j--) 
        L->elem[j+1] = L->elem[j];
    L->elem[i-1] = e;
    ++L->length;
    return OK;
}

// 顺序表的删除 在顺序表L中删除第i个元素 i值的合法范围是 1 <= i <= L.length T(n)
Staues ListDelete(SqList *L,int i)
{
    if(i < 1 || i > L->length)
        return ERROR;
    for (int  j = i; j <= L->length-1; j++)
    {
        L->elem[j-1] = L->elem[j];
    }
    --L->length;
    return OK;
}

// 销毁线性表
Staues DestoryList(SqList *L)
{
    free(L->elem);
    L->elem = NULL;
    L->length = 0;
    return OK;
}

//将L重置为空表
Staues ClearList(SqList* L)
{
    L->length = 0;
    return OK;
}

// 判断List是否存在 空表返回True 否则返回False
Staues ListEmpyt(SqList L)
{
    if(L.length == 0)
        return TRUE;
    else
        return FALSE;
}

// 判断List表长
Staues ListLength(SqList L)
{
    return L.length;
}

// 若cur_e是L的数据元素，且不是第一个，则用pre_e返回其前驱，否则操作失败，pre_e无定义 T(n)
Elemtype* PriorElem(SqList L,Elemtype cur_e,Elemtype* pre_e)
{
    pre_e = L.elem;
    for (int i = 0; i < L.length; i++)
    {
        if (L.elem[i] == cur_e)
        {
            if (i != 0)
            {
                return pre_e+i-1;
            }   
        }
        
    }
    pre_e = NULL;
    return pre_e;
}

// 操作结果 若cur_e是L的数据元素，且不是最后一个，则用next_e返回其后继，否则操作失败，next_e无定义 T(n)
Elemtype* NextElem(SqList L,Elemtype cur_e,Elemtype* next_e)
{
    next_e = L.elem;
    for (int i = 0; i < L.length; i++)
    {
        if (L.elem[i] == cur_e)
        {
            if (i != L.length-1)
            {
                return next_e+i+1;
            }   
        }       
    }
    next_e = NULL; 
    return next_e;
}

// 操作结果 对线性表L进行遍历，在遍历过程中对L的每个结点访问一次 T(n)
Staues TraverseList(SqList L)
{
    for (int  i = 0; i < L.length; i++)
    {
        printf("%d\t",L.elem[i]);
    }
    printf("\n");
}

上面是Sqlist的实现 下面是测试代码

#include "Sqlist.h"      
// 简单测试一下线性表的功能

void func(SqList L)
{
    L.elem[2] = 200;
}

int main()
{
    SqList L;
    InitList(&L);
    for (int  i = 0; i < 10; i++) //不断的在第一个位置添加元素
    {
        ListInsert(&L,1,i);   
    }
    TraverseList(L);
    printf("%d\n",ListLength(L));
    int c;
    GetElem(L,2,&c);
    printf("c = %d\n",c);
    ListDelete(&L,2);
    TraverseList(L);
    int* next_e;
    int* pre_e; 
    // pre_e = L.elem;   L.elem 等价于 &L.elem[0] 
    // printf("first %d\n",*(pre_e+1));
    next_e = NextElem(L,5,next_e);
    printf("next_e = %d\n",*next_e);
    // pre_e = PriorElem(L,9,pre_e);
    // printf("pre_e = %d\n",*pre_e);
    pre_e = PriorElem(L,5,pre_e);
    printf("pre_e = %d\n",*pre_e);
    L.elem[0]  = 100; // 从测试结果看 说明是直接对顺序表操作 顺序表发生改变
    TraverseList(L); 
    func(L);    // 从测试结果看 说明是直接对顺序表操作 顺序表发生改变
    TraverseList(L); 
    return 0;
}

运行结果