链式存储[数据结构]

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

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

typedef int ElemType;
typedef int Status;

/*
 * 存储结构
 */
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LNode, *LinkedList;

/*
 * 初始化线性表
 */
void InitList(LinkedList *L)
{
    *L = (LinkedList)malloc(sizeof(LNode));
    if (!L)
    { //判断是否分配成功
        exit(OVERFLOW);
    }
    (*L)->next = NULL;
}

/*
 * 销毁线性表
 */
void DestroyList(LinkedList *L)
{
    LinkedList temp; //定义临时链表
    while (*L)
    {
        temp = (*L)->next;
        free(*L);
        *L = temp; //往后迭代
    }
}

/*
 * 清空线性表
 */
void ClearList(LinkedList L)
{
    LinkedList temp = L->next;
    L->next = NULL;
    DestroyList(&temp);
}

/*
 * 判断是否为空
 */
Status isEmpty(LinkedList L)
{
    if (L->next)
    {
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}

/*
 * 获取长度
 */
int GetLength(LinkedList L)
{
    int i = 0;
    LinkedList p = L->next;
    while (p)
    {
        i++;
        p = p->next;
    }
    return i;
}

/*
 * 根据位置获取元素
 */
Status GetElem(LinkedList L, int i, ElemType *e)
{
    int j = 1;
    LinkedList p = L->next;
    while (p && j < i)
    {
        j++;
        p = p->next;
    }
    if (!p || j > i)
    {
        return ERROR;
    }
    *e = p->data;
    return OK;
}

/**
 * 根据位置获取元素
 */
Status GetIndexOfElem(LinkedList L, int i)
{
    if (i > GetLength(L)) //判断位置是否越界
    {
        return ERROR;
    }
    LinkedList p = L->next;
    int count = 1;
    while (p)
    {
        if (i == count)
        {                   //判断查找的位置是否相等
            return p->data; //返回目标位置的元素
        }
        count++;
        p = p->next;
    }
}

/**
 *比较两个元素是否相等
 */
Status compare(ElemType e1, ElemType e2)
{
    if (e1 == e2)
    {
        return 0;
    }
    else if (e1 < e2)
    {
        return -1;
    }
    else
    {
        return 1;
    }
}

/*
 * 查找指定元素的位置
 */
int FindElem(LinkedList L, ElemType e, Status (*compare)(ElemType, ElemType))
{
    int i = 0;
    LinkedList p = L->next;
    while (p)
    {
        i++;
        if (!compare(p->data, e)) //判断是否相等
        {
            return i;
        }
        p = p->next;
    }
    return 0;
}

/*
 * 获取前驱元素
 */
Status PreElem(LinkedList L, ElemType cur_e, ElemType *pre_e)
{
    LinkedList q, p = L->next;
    while (p->next)
    {
        q = p->next;
        if (q->data == cur_e)
        {
            *pre_e = p->data;
            return OK;
        }
        p = q;
    }
    return ERROR;
}

/*
 * 获取后继元素
 */
Status NextElem(LinkedList L, ElemType cur_e, ElemType *next_e)
{
    LinkedList p = L->next;
    while (p->next)
    {
        if (p->data == cur_e)
        {
            *next_e = p->next->data;
            return OK;
        }
        p = p->next;
    }
    return ERROR;
}

/*
 * 插入元素
 */
Status InsertElem(LinkedList L, int i, ElemType e)
{
    int j = 0;
    LinkedList s, p = L;
    while (p && j < i - 1)
    {
        j++;
        p = p->next;
    }
    if (!p || j > i - 1)
    {
        return ERROR;
    }
    s = (LinkedList)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return OK;
}

/*
 * 删除元素并返回值
 */
Status DeleteElem(LinkedList L, int i, ElemType *e)
{
    int j = 0;
    LinkedList q, p = L;
    while (p->next && j < i - 1)
    {
        j++;
        p = p->next;
    }
    if (!p->next || j > i - 1)
    {
        return ERROR;
    }
    q = p->next;
    p->next = q->next;
    *e = q->data;
    free(q);
    return OK;
}

/*
 * 遍历线性表
 */
void TraverseList(LinkedList L)
{
    LinkedList p = L->next;
    while (p)
    {
        printf("%-4d", p->data);
        p = p->next;
    }
}

int main(int args, const char *argv[])
{
    LinkedList L;
    InitList(&L);
    ElemType e;
    int i;
    if (L)
    {
        printf("Init success\n");
    }

    if (isEmpty(L))
    { // 判断链表是否为空
        printf("list is empty\n");
    }

    for (i = 0; i < 10; i++)
    { // 插入元素
        InsertElem(L, i + 1, i);
    }

    if (GetElem(L, 1, &e))
    { // 获取元素的值
        printf("The first element is %d\n", e);
    }

    printf("length is %d\n", GetLength(L)); // 获取表长

    printf("The 5 at %d\n", FindElem(L, 5, *compare)); // 查找元素

    PreElem(L, 6, &e); // 获取元素 6 的前驱元素
    printf("The 6's previous element is %d\n", e);

    NextElem(L, 6, &e); // 获取元素 6 的后继元素
    printf("The 6's next element is %d\n", e);

    DeleteElem(L, 1, &e); // 删除元素
    printf("delete first element is %d\n", e);

    printf("list:");
    TraverseList(L); // 遍历链表
    printf("第5个位置的元素是%-4d ", GetIndexOfElem(L, 5));
    DestroyList(&L); // 销毁线性表
    if (!L)
    {
        printf("\nDestroy success\n");
    }
}