单链表的创建、插入、删除等操作

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

#define OK 1
#define ERROR 0

typedef int Status;
typedef int ELemType;


/*用结构指针描述单链表*/
typedef struct Node
{
    ELemType data;  //数据域

    struct Node* next;  //指针域

}Node, *LinkList;

//typedef struct Node* LinkList;
/*
头插法建立单链表：
虽然简单，但生成的链表中结点的次序和输入的顺序相反。
*/
void CreateListHead(LinkList *L, int n)
{
    int i;
    LinkList p;
    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;
    }
}
/************尾插法创建单链表*************/
void CreateListTail(LinkList *L, int n)
{
    int i;
    LinkList p, r;
    srand(time(0)); //初始化随机数种子
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;

    for(i = 0; i < n; i++)
    {
         p = (LinkList)malloc(sizeof(Node));

         p->data = rand()%100 + 1;

         r->next = p;
         r = p;
    }
    r->next = NULL;
}
/*
获得链表第i个数据的算法：
1，声明一个结点p指向链表的第一个结点，初始化j从1开始;
2.当j < i时，就遍历链表，让p的指针向后移动，不断指向下
一个结点，j + 1;
3.若到链表末尾p为空，则说明第i个元素不存在；
4.否则查找成功，返回结点p的数据。
*/
Status GetElem(LinkList *L, int i, ELemType *e)
{
    int j;
    LinkList p;

    p = (*L)->next;    //L为带头结点的单链表的头指针
    j = 1;

    while(p && j < i)   //j == i找到了
    {
        p = p->next;
        ++j;
    }
    if(!p || j > i)
    {
        return ERROR;
    }
    *e = p->data;

    return OK;
}
/*
在带头结点的单链线性表L中第i个位置之前插入元素e算法：

1.声明一个结点p指向链表头结点，初始化j从1开始；
2.当j < i - 1时，遍历链表，让p的指针向后移动，不断指向下一个
结点，j累加1；
3.若到链表末尾p为空，则说明第i个元素不存在；
4.否则查找成功，在系统中生成一个空结点s；
5.将数据元素e赋值给s->data；
6.单链表的插入，返回成功。
*/
Status ListInsert(LinkList *L, int i, ELemType e)
{
    int j;
    LinkList p, s;

    j = 1;
    p = *L; //p指向头结点
    while(p && j < i - 1)   //寻扎第i - 1个结点
    {
        p = p->next;
        ++j;
    }
    if(!p || j > i - 1)
    {
        return ERROR;
    }

    s = (LinkList)malloc(sizeof(Node));
    s->data = e;

    s->next = p->next;
    p->next = s;

    return OK;
}
/*
单链表第i个数据删除结点的算法：
1，声明一个结点p指向链表的第一个结点，初始化j从1开始;
2.当j < i时，就遍历链表，让p的指针向后移动，不断指向下
一个结点，j + 1;
3.若到链表末尾p为空，则说明第i个元素不存在；
4.否则查找成功，将欲删除结点p->next赋值给q;
5.单链表的删除标准语句p->next = q->next;
6.将q结点中的数据赋值给e,作为返回；
7.释放q结点。
*/
Status ListDele(LinkList *L, int i, ELemType *e)
{
    int j;
    LinkList p, q;

    p = *L; //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;
    //p->next = p->next->next;

    *e = q->data;
    free(q);

    return OK;
}
/*
Status ListDele(LinkList L, int i, ELemType *e)
{
    int j;
    LinkList p, q;

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

    //p->next = p->next->next;
    q = p->next;
    p->next = q->next;

    *e = q->data;
    free(q);

    return OK;
}
*/
/*
单链表的整表删除算法：
1.声明结点p和q；
2.将第一个结点赋值给p，下一个结点赋值给q；
3.循环执行释放p和将q赋值给p的操作。
*/
Status ClearList(LinkList *L)
{
    LinkList p, q;
    p = (*L)->next;

    while(p)
    {
        q = p->next;

        free(p);
        p = q;
    }
    (*L)->next = NULL;

    return OK;
}