《数据结构与算法》-线性表的顺序表示和实现

 源码

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

/* 错误码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1

/* 类型重定义 */
typedef int Status;
typedef int Boolean;
typedef int ElemType;

#define LIST_INIT_SIZE 10
#define LIST_INCREMENT 2

/* 顺序表的类型定义 */
typedef struct
{
    ElemType *elem;
    int length;
    int listsize;
} SqList;

// 操作结果：构造一个空的顺序线性表L
Status ListInit(SqList *L)
{
    L->elem = (ElemType *)malloc(sizeof(ElemType) * LIST_INIT_SIZE);
    if (L->elem == NULL) // 内存分配失败，函数返回
    {
        return ERROR;
    }

    L->length = 0;                // 空表长度为0
    L->listsize = LIST_INIT_SIZE; // 初始存储容量

    return OK;
}

// 初始条件：顺序线性表 L 已存在
// 操作结果：销毁顺序线性表 L
void ListDestroy(SqList *L)
{
    free(L->elem);
    L->elem = NULL;
    L->length = 0;
    L->listsize = 0;
}

// 初始条件：顺序线性表L已存在
// 操作结果：将L重置为空表
void ListClear(SqList *L)
{
    L->length = 0;
}

// 初始条件：顺序线性表L已存在
// 操作结果：若L为空表，则返回TRUE，否则返回FALSE
Status ListEmpty(SqList L)
{
    if (L.length == 0)
        return TRUE;
    else
        return FALSE;
}

// 初始条件：顺序线性表 L已存在
// 操作结果：返回 L 中数据元素个数
int ListLength(SqList L)
{
    return L.length;
}

// 初始条件：顺序线性表 L 已存在, 1≤i≤ListLength(L)。
// 操作结果：用 e 返回 L 中第 i 个数据元素的值
Status GetElem(SqList L, int i, ElemType *e)
{
    if (i < 1 || i > ListLength(L))
        return ERROR;

    *e = L.elem[i - 1];
    return OK;
}

// 初始条件：顺序线性表 L 已存在，compare() 是数据元素判定函数(满足为 1，否则为 0)
// 操作结果：返回 L 中第 1 个与 e 满足关系 compare() 的数据元素的位序。
// 若这样的数据元素不存在，则返回值为 0
int LocateElem(SqList L, ElemType e, Status (*compare)(ElemType, ElemType))
{
    ElemType *p;
    int i = 1;  // i 的初值为第 1 个元素的位序
    p = L.elem; // p 的初值为第 1 个元素的存储位置
    while (i <= ListLength(L) && !compare(*p++, e))
        ++i;

    if (i <= L.length)
        return i;
    else
        return 0;
}

// 初始条件：顺序线性表 L 已存在
// 操作结果：若 cur_e 是 L 的数据元素，且不是第一个，则用 pre_e 返回它的前驱，
// 操作失败，pre_e 无定义
Status PriorElem(SqList L, ElemType cur_e, ElemType *pre_e)
{
    int i = 2;
    ElemType *p = L.elem + 1;
    while (i <= L.length && *p != cur_e)
    {
        p++;
        i++;
    }

    if (i > L.length)
    {
        return INFEASIBLE; // 操作失败
    }
    else
    {
        *pre_e = *--p;
        return OK;
    }
}

// 初始条件：顺序线性表 L 已存在
// 操作结果：若 cur_e 是 L 的数据元素，且不是最后一个，则用 next_e 返回它的后继，
// 否则操作失败，next_e 无定义
Status NextElem(SqList L, ElemType cur_e, ElemType *next_e)
{
    int i = 1;
    ElemType *p = L.elem;
    while (i < L.length && *p != cur_e)
    {
        i++;
        p++;
    }
    if (i == L.length)
    {
        return INFEASIBLE; // 操作失败
    }
    else
    {
        *next_e = *++p;
        return OK;
    }
}

// 初始条件：顺序线性表 L 已存在，1≤i≤ListLength(L)+1
// 操作结果：在 L 中第 i 个位置之前插入新的数据元素 e，L 的长度加 1
Status ListInsert(SqList *L, int i, ElemType e)
{
    ElemType *newbase, *q, *p;
    if (i < 1 || i > L->length + 1)
        return ERROR;
    if (L->length >= L->listsize)
    {
        if (!(newbase = (ElemType *)realloc(L->elem, (L->listsize + LIST_INCREMENT) * sizeof(ElemType))))
            exit(-1);
        L->elem = newbase;
        L->listsize += LIST_INCREMENT;
    }
    q = L->elem + i - 1;                           // q为插入位置
    for (p = L->elem + L->length - 1; p >= q; --p) // 插入位置及之后的元素右移
        *(p + 1) = *p;
    *q = e;      // 插入e
    ++L->length; // 表长增1

    return OK;
}

// 初始条件：顺序线性表 L 已存在，1≤i≤ListLength(L)
// 操作结果：删除 L 的第 i 个数据元素，并用e返回其值，L 的长度减 1
Status ListDelete(SqList *L, int i, ElemType *e)
{
    ElemType *p, *q;
    if (i < 1 || i > L->length)
        return ERROR;
    p = L->elem + i - 1;         // p 为被删除元素的位置
    *e = *p;                     // 被删除元素的值赋给 e
    q = L->elem + L->length - 1; // 表尾元素的位置
    for (++p; p <= q; ++p)       // 被删除元素之后的元素左移
        *(p - 1) = *p;
    L->length--; // 表长减 1

    return OK;
}

// 初始条件：顺序线性表 L 已存在
// 操作结果：依次对 L 的每个数据元素调用函数 vi()
// vi() 的形参加'*'，表明可通过调用 vi() 改变元素的值
void ListTraverse(SqList L, void (*vi)(ElemType *))
{
    ElemType *p;
    int i;
    p = L.elem;
    for (i = 1; i <= ListLength(L); i++)
        vi(p++);
    printf("\n");
}

static void print_list_element(ElemType * element)
{
    printf("%d ", *element);
}

static Status compare_equal(ElemType a, ElemType b)
{
    if(a == b)
        return 1;
    else
        return 0;
}

int main(int argc, char *argv[])
{
    printf("hello world\n");
    SqList L;
    ListInit(&L);
    int i = 0;
    ElemType Delete_Ele;
    ElemType Insert_Ele;
    ElemType Get_Ele;

    for(i = 1; i <= LIST_INIT_SIZE; i++)
        ListInsert(&L, i, i * 2);

    ListTraverse(L, print_list_element);

    ListDelete(&L, 8, &Delete_Ele);
    printf("delete data is %d\r\n", Delete_Ele);

    Insert_Ele = 100;
    ListInsert(&L, 8, Insert_Ele);
    ListTraverse(L, print_list_element);


    GetElem(L, 8, &Get_Ele);
    printf("8 get ele is %d\r\n", Get_Ele);

    int locate_index = 0;
    locate_index = LocateElem(L, 12, compare_equal);
    printf("12 locate is %d\r\n", locate_index);

    ElemType pre_element = 0;
    PriorElem(L, 18, &pre_element);
    printf("18 prior data is %d\r\n", pre_element);

    ElemType next_element = 0;
    NextElem(L, 6, &next_element);
    printf("6 next data is %d\r\n", next_element);

    while (1)
    {
        /* code */
    }

    return 0;
}
/* 输出结果
hello world
2 4 6 8 10 12 14 16 18 20
delete data is 16
2 4 6 8 10 12 14 100 18 20
8 get ele is 100
12 locate is 6
18 prior data is 100
6 next data is 8
*/

 

 编译命令

 gcc sequence_list.c  -o list

 

执行

 ./list