《数据结构》-线性表的链式表示及实现(带有头节点)

/* 
带头结点的单链表
头指针 -> 头结点 -> 首元结点 -> --- -> 尾结点

几个重要的操作：
p = L; // p 指向头结点
p = L->next // p 指向首元结点
p = p->next; // p 指向下一个结点
*/

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;

typedef struct node /* 声明结点的类型和指向结点的指针类型 */
{
    ElemType data;     /* 结点的数据域 */
    struct node *next; /* 结点的指针域 */
} Lnode, *LinkList;    /* LinkList 为指向 Lnode 的指针类型 */

/* 初始化一个单链表，即构造一个空表 
生成新结点作为头结点，用头指针 L 指向头结点
将头结点的指针域清空
*/
Status list_init(LinkList *L)
{
    *L = (LinkList)malloc(sizeof(Lnode)); /* L 是头指针， 头指针 -> 头结点 */
    if (*L == NULL)
    {
        printf("malloc failed\r\n");
        return ERROR;
    }

    (*L)->next = NULL;
    (*L)->data = 0;

    return OK;
}

/* 从头指针开始，依次释放所有结点 */
void list_destroy(LinkList *L)
{
    LinkList p;
    while (*L) /* 第一次 *L 指向头结点，如果头结点非空，依次释放所有结点 */
    {
        p = (*L)->next;
        free(*L);
        *L = p;
    }
}

/* 判断链表是否为空 链表中无数据，称为空链表(头指针和头结点仍然在) */
Status list_isempty(LinkList L)
{
    if (L->next == NULL)
        return TRUE;
    else
        return FALSE;
}

/* 算法思路：链表仍存在，但链表中无数据，成为空链表（头指针和头结点仍然在）*/
void list_clear(LinkList L) // 不改变L
{                           // 初始条件：线性表L已存在。操作结果：将L重置为空表
    LinkList p, q;
    p = L->next; // p指向首元结点
    while (p)    // 没到表尾
    {
        q = p->next;
        free(p);
        p = q;
    }
    L->next = NULL; // 头结点指针域为空
}

/* 算法思路：从首元结点开始，依次计数所有结点 */
int list_length(LinkList L)
{ // 初始条件：线性表L已存在。操作结果：返回L中数据元素个数
    int i = 0;
    LinkList p = L->next; // p指向首元结点
    while (p)             // 没到表尾
    {
        i++;
        p = p->next;
    }
    return i;
}

Status get_elm(LinkList L, int i, ElemType *e) // 算法2.8
{                                               // L为带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
    int j = 1;                                  // j为计数器
    LinkList p = L->next;                       // p指向第一个结点-首元结点
    while (p && j < i)                          // 顺指针向后查找，直到p指向第i个元素或p为空
    {
        p = p->next;
        j++;
    }
    if (!p || j > i) // 第i个元素不存在
        return ERROR;
    *e = p->data; // 取第i个元素

    return OK;
}

/*
算法步骤：
从第一个结点起，依次与 e 相比较
如果找到一个其值与 e 相等的数据元素，则返回其在链表中的 位置 或 地址
如果查遍整个链表都没有找到其值和 e 相等的元素，则返回 0 或 NULL
时间复杂度：O(n)
*/
int locate_elm(LinkList L, ElemType e, Status (*compare)(ElemType, ElemType))
{ // 初始条件: 线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0)
    // 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。
    //           若这样的数据元素不存在，则返回值为0
    int i = 0;
    LinkList p = L->next; // p 指向首元结点
    while (p)
    {
        i++;
        if (compare(p->data, e)) // 找到这样的数据元素
            return i;
        p = p->next;
    }
    return 0;
}

Status prior_elm(LinkList L, ElemType cur_e, ElemType *pre_e)
{ // 初始条件: 线性表L已存在
    // 操作结果: 若 cur_e 是 L 的数据元素，且不是第一个，则用 pre_e 返回它的前驱，
    //           返回OK；否则操作失败，pre_e无定义，返回 ERROR
    LinkList q, p = L->next; // p 指向首元结点
    while (p->next)          // p 所指结点有后继
    {
        q = p->next; // q 为 p 的后继
        if (q->data == cur_e)
        {
            *pre_e = p->data;
            return OK;
        }
        p = q; // p向后移
    }
    return ERROR;
}


Status next_elm(LinkList L, ElemType cur_e, ElemType *next_e)
{ // 初始条件：线性表L已存在
    // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
    //           返回OK;否则操作失败，next_e无定义，返回 ERROR
    LinkList q, p = L->next;       // p 指向首元结点
    while(p->next)
    {
        if(p->data == cur_e)
        {
            *next_e = p->next->data;
            return OK;
        }

        p = p->next;
    }

    return ERROR;
}

/*
时间复杂度
不需要查找：O(1)
需要查找：O(n)
*/
Status list_insert(LinkList L, int i, ElemType e) // 算法2.9。不改变L
{                                                // 在带头结点的单链线性表 L 中第 i 个位置之前插入元素e
    int j = 0;
    LinkList p = L, s;
    while (p && j < i - 1) // 寻找第i-1个结点
    {
        p = p->next;
        j++;
    }
    if (!p || j > i - 1) // i小于1或者大于表长
        return ERROR;

    s = (LinkList)malloc(sizeof(Lnode)); // 生成新结点
    if (s == NULL)
        return ERROR;

    s->data = e; // 插入 L 中
    s->next = p->next;
    p->next = s;

    return OK;
}

/*
时间复杂度
不需要查找：O(1)
需要查找：O(n)
*/
Status list_delete(LinkList L, int i, ElemType *e) // 算法2.10。不改变L
{                                                 // 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
    int j = 0;
    LinkList p = L, q;
    while (p->next && j < i - 1) // 寻找第i个结点，并令p指向其前驱
    {
        p = p->next;
        j++;
    }

    if (!p->next || j > i - 1) // 删除位置不合理
        return ERROR;

    q = p->next; // 删除并释放结点
    p->next = q->next;
    *e = q->data;
    free(q);

    return OK;
}

/* 
遍历单链表 
*/
void list_traverse(LinkList L, void (*vi)(ElemType))
{ // 初始条件：线性表 L 已存在。操作结果：依次对 L 的每个数据元素调用函数 vi()
    LinkList p = NULL;

    p = L->next;
    while(p)
    {
        vi(p->data);
        p = p->next;
    }

    return;
}

int main(int argc, char *argv[])
{
    Status res = 0;
    LinkList L = NULL; /* 定义一个头指针，头指针只是一个指针 其指向头结点 */
    printf("tyustli\r\n");

    list_init(&L); /* 头结点的 next 为空，构造了一个空的带头结点的单链表 */
    res = list_isempty(L);
    if (res == TRUE)
    {
        printf("list is empty\r\n");
    }

    list_destroy(&L);
    if (L != NULL)
    {
        printf("destory list failed\r\n");
    }

    list_init(&L);

    return 0;
}

/***************** end of file *****************/