单链表以及静态链表的实现

注意：
我认为对于数据结构的深入理解并不是掌握书本上的概念，最重要的是自己的动手编写过程，其中有不少饶人的注意点，望读者有了基本了解之后，动手能够亲自实现，这是一个不一样的过程。

**链表中的数据是以节点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
· 以“结点的序列”表示线性表称作线性链表（单链表）
· 单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。
· 因此，查找第 i 个数据元素的基本操作为：移动指针，比较 j 和 i
单链表
1、链接存储方法
链接方式存储的线性表简称为链表（Linked List）。
链表的具体存储表示为：
① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）
② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)）
注意：
链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。
2、链表的结点结构
┌───┬───┐
│data │next │
└───┴───┘
data域–存放结点值的数据域
next域–存放结点的直接后继的地址（位置）的指针域（链域）
注意：
①链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。
②每个结点只有一个链域的链表称为单链表（Single Linked List）。
【例】线性表（bat，cat，eat，fat，hat，jat，lat，mat）的单链表示如示意图
3、头指针head和终端结点指针域的表示
单链表中每个结点的存储地址是存放在其前趋结点next域中，而开始结点无前趋，故应设头指针head指向开始结点。
注意：
链表由头指针唯一确定，单链表可以用头指针的名字来命名。
终端结点无后继，故终端结点的指针域为空，即NULL。
4、单链表注意点
①LinkList和ListNode是不同名字的同一个指针类型（命名的不同是为了概念上更明确）
②*LinkList类型的指针变量head表示它是单链表的头指针
③ListNode类型的指针变量p表示它是指向某一结点的指针
5、编写过程应了解的函数
①生成结点变量的标准函数
p=( ListNode *)malloc(sizeof(ListNode))；
//函数malloc分配一个类型为ListNode的结点变量的空间,并将其首地址放入指针变量p中
②释放结点变量空间的标准函数
free(p)；//释放p所指的结点变量空间
③结点分量的访问
利用结点变量的名字*p访问结点分量
方法一：(*p).data和(*p).next
方法二：p-﹥data和p-﹥next
④指针变量p和结点变量*p的关系
指针变量p的值——结点地址
结点变量*p的值——结点内容
(*p).data的值——p指针所指结点的data域的值
(*p).next的值——*p后继结点的地址
*((*p).next)——*p后继结点
注意：
① 若指针变量p的值为空（NULL），则它不指向任何结点。此时，若通过*p来访问结点就意味着访问一个不存在的变量，从而引起程序的错误。
② 有关指针类型的意义和说明方式的详细解释
可见，在链表中插入结点只需要修改指针。但同时，若要在第 i 个结点之前插入元素，修改的是第 i-1 个结点的指针。
因此，在单链表中第 i 个结点之前进行插入的基本操作为:
找到线性表中第i-1个结点，然后修改其指向后继的指针

代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define Error 0
#define Ok 1
typedef int  ElemType;
typedef int  Status;
typedef struct Node
{
    ElemType  data;
    struct Node *next;

}Node,*LinkList;

typedef struct Node* LinkList;

/**
 *  获得单链表的元素
 */
Status GetElem_L(LinkList L, int i, ElemType *e)
{
    //工作指针后移；
    int j = 1;
    LinkList p ;

    p = L->next;


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

    if (!p || j > i) {
        return Error;
    }

    *e = p->data;
    return Ok;

}

/**
 *  单链表的插入
 */
LinkList ListInsert(LinkList *L, int i, ElemType e)
{
    int j = 1;
    LinkList p,s;

    p = *L;

    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 *L;
}

/**
 *  单链表的删除
 */
LinkList ListDelete(LinkList *L, int i)
{
    int j = 1;
    LinkList p;

    p = *L;

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

    if (!p || j > i) {
        return Error;
    }

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

//    e = p->data;

    free(p->next);
    return *L;


}

/**
 *  单链表的整表创建
 动态生成
 （头插法)始终让新节点插在第一的位置
 */
LinkList CreatList_LH(LinkList L,int n)
{
    LinkList p;
    int i ;

    L = (LinkList)malloc(sizeof(Node));
    L->next = NULL;

    srand((unsigned)time(0));

    for (i = 0; i < n; i++) {
        p  = (LinkList)malloc(sizeof(Node));
        p->data = rand()%100 + 1;
        //printf("%d ",p->data);
        p->next = L->next;
        L->next = p;

    }

    return L;

}

/**
 *  尾插法
 */
LinkList CreatList_LD(LinkList *L,int n)
{
    LinkList p,r;
    int i ;


    srand((unsigned)time(0));

    *L = (LinkList)malloc(sizeof(Node));
    //L->next = NULL;
    r = *L;

    for (i = 0; i < n; i ++) {
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand()%100 + 1;
        //printf("%d ",p->data);
        r->next = p;
        r = p;
    }

    r->next = NULL;

    return *L;
}

/**
 *  单链表的清除
 */
Status ClearList(LinkList L)
{
    LinkList q,p;

    p = L->next;

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

    L->next = NULL;
    return Ok;

}


Status LengthOfList(LinkList L)
{
    int length;

    while (L->next != NULL) {
        length++;
        L = L->next;

    }
    return length;
}

ElemType GetMidNode(LinkList *L)
{
    LinkList search,mid;

    mid = search = *L;
    while (search->next != NULL) {

    if (search->next->next != NULL) {

        search = search->next->next;
        mid = mid->next;
    }
    else
    {
        search = search->next;
        mid = mid->next;
    }
    }

    return mid->data;
}

int main()
{

    LinkList list,start;

    /*  printf("请输入单链表的数据：");
     list = LinkedListCreatH();
     for(start = list->next; start != NULL; start = start->next)
     printf("%d ",start->data);
     printf("/n");
     */  printf("请输入单链表的个数：");
    int j = 0;
    scanf("%d",&j);

    list = CreatList_LD(&list, j);
    for(start = list->next; start != NULL; start = start->next)
        printf("%d ",start->data);

    printf("\n");

    int length = LengthOfList(list);
    printf("%d",length);

    printf("\n");
    int i;
    ElemType x;


    printf("请输入插入数据的位置：");
    scanf("%d",&i);


    while (i > j||i <= 0) {
        printf("请输入插入数据的位置：");
        scanf("%d",&i);
    }
    printf("请输入插入数据的值：");
    scanf("%d",&x);
    list = ListInsert(&list, i, x);
    for(start = list->next; start != NULL; start = start->next)
            printf("%d ",start->data);

     printf("\n");
    ElemType k;
    k =  GetMidNode(&list);
    printf("%d",k);


    printf("\n");
    printf("请输入删除数据的位置：");
    scanf("%d",&i);
    list = ListDelete(&list, i);
    for(start = list->next; start != NULL; start = start->next)
    {   printf("%d ",start->data);}
    printf("\n");


    ClearList(list);

    return 0;
}

**用数组描述的链表，即称为静态链表。
· 在C语言中，静态链表的表现形式即为结构体数组，结构体变量包括数据域data和游标cur。

· 这种存储结构，仍需要预先分配一个较大的空间，但在作为线性表的插入和删除操作时不需移动元素，仅需修改指针，故仍具有链式存储结构的主要优点。

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define MaxSize 100
typedef int  ElemType;
typedef struct {
    ElemType data;
    int cur;

}SList,StaticLinkList[MaxSize];

/**
 *  初始化
 */
void init_sl(StaticLinkList space)
{
    int i;
    for (i = 0; i < MaxSize - 1; i++) {
        space[i].cur = i +1;
    }

    space[MaxSize-1].cur = 0;
}

/**
 *  分配空闲结点
 */

int malloc_sl(StaticLinkList space)
{
    int i = space[0].cur;
    if (i) {
        space[0].cur = space[i].cur;
    }
    return i;
}

int GetListLength(StaticLinkList space)
{
    int j = 0;
    int k = space[MaxSize - 1].cur;
    while (k) {
        j++;
        k = space[k].cur;
    }
    return j;
}


void ListInsert(StaticLinkList L, int i, ElemType e)
{

    int k = MaxSize - 1;

    if (i < 1|| i > GetListLength(L) + 1) {
        return;
    }

    int v = malloc_sl(L);
    {

    for (int j= 0 ; j < i- 1; j++) {
        k = L[k].cur;//插入的前一个结点
    }
        L[v].data = e;
        L[v].cur = L[k].cur;
        L[k].cur = v;
    }
}

void Free_SLL(StaticLinkList L,int j)
{
    L[j].cur = L[0].cur;
    L[0].cur = j;
}
/**
 *  删除i位置的元素
 */
void DeleteList(StaticLinkList L, int i)
{
    int k = MaxSize - 1;

    if (i < 1|| i > GetListLength(L) + 1) {
        return;
    }

    for (int j = 0; j < i -1; j++) {
        k = L[k].cur;
    }

    int  temp = L[k].cur;
    L[k].cur = L[temp].cur;
    Free_SLL(L, temp);
}



void Print(StaticLinkList L) //打印链表
{
    int k = L[MaxSize - 1].cur;
    while(k)
    {
        printf("%d ",L[k].data);
        k = L[k].cur;
    }
    printf("\n");
}


int main(int argc, const char * argv[]) {

    srand((unsigned)time(0));

    StaticLinkList L;
    init_sl(L); //初始化链表
    for(int i = 0;i < 8;++i)
        ListInsert(L, i, rand()%100 + 1);
    Print(L); //输出链表


    int i,j;
    printf("请输入插入的位置：");
    scanf("%d",&j);
    printf("请输入插入的值：");
    scanf("%d",&i);
    ListInsert(L,j,i); //在链表的第3个位置插入22
    Print(L);


    printf("请输入删除的位置：");
    scanf("%d",&j);
    DeleteList(L,j);
    Print(L);
    return 0;
}