数据结构学习随笔之单链表的创建、插入、删除、清空

记录代码方便以后随时复习，逻辑比较简单。

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

#define MAXSIZE 20
#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;
}Node;
typedef struct Node *LinkList;

Status Getelem(LinkList L, int i, ElemType *e)
{
    int j;
    LinkList p;

    p = L->next;
    j = 1;

    while (p && j < i)
    {
        p = p->next;
        j++;
    }

    if (!p || j > i)
    {
        return error;
    }
    *e = p->data;
    return ok;
}

Status ListInsert(LinkList *L, int i, ElemType e)
{
    int j;
    LinkList p, s;

    p = *L;
    j = 1;

    while (p && j < i)
    {
        p = p->next;
        j++;
    }
    if (!p || j > i)
        return error;
    s = (LinkList)malloc(sizeof(Node));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return ok;
}

Status ListDelete(LinkList *L, int i, ElemType *e)
{
    int j;
    LinkList p, q;

    p = L;
    j = 1;
    while (p->next && j < i)
    {
        p = p->next;
        j++;
    }
    if (!(p->next) || j > i)
        return error;

    q = p->next;
    p->next = q->next;
    *e = q->data;
    free(q);
    return ok;
}

// 头插法
void CreateListHead(LinkList *L, int n)
{
    LinkList p;
    int i;

    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;

    for (i = 0; i < n; i++)
    {
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand() % 100 + 1;
        p->next = (*L)->next;
        (*L)->next = p;
    }
}

// 尾插法
// 注意L与r的关系，L是指整个单链表，而r是指向尾结点的变量，也就是指向尾结点的工作指针
void CreateListTail(LinkList *L, int n)
{
    LinkList p, r;
    int i;
    srand(time(0));

    *L = (LinkList)malloc(sizeof(Node));
    r = *L;  /*r为指向尾部的结点*/

    for (i = 0; i < n; i++)
    {
        p = (Node *)malloc(sizeof(Node));
        p->data = rand() % 100 + 1;
        r->next = p;
        r = p;
    }
    r->next = NULL; //表示当前链表结束
}

//单链表的整表删除
/*
    算法思路如下：
        1、声明一结点p和q
        2、将第一个结点赋值给p
        3、循环：
            将下一结点赋值给q；
            释放p
            将q赋值给p
    实现代码算法如下：
*/
Status ClearList(LinkList *L)
{
    LinkList p, q;
    p = (*L)->next; // p指向第一个结点
    while (p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL; //头结点指针域为空
    return ok;
}

/*
    单链表结构与顺序存储结构的优缺点：
        顺序存储查找方便，插入删除较为麻烦，且预分配空间容易造成空间浪费
        单链表查找时间复杂度较高i，但插入和删除极为灵活，且空间是按需分配，不会造成浪费
    据此可以得出：
        若线性表需要频繁查找，很少进行插入删除操作时，宜采用顺序存储结构
        若需要频繁插入和删除时，宜采用单链表结构。
*/

int main()
{
    return 0;
}