线性表的链式存储结构

概念：
1. 数据域：存储数据元素信息的域
2. 指针域：存储直接后继的位置的与域成为指针域。
3. 指针：指针域中存储的信息叫指针或链。
4. 节点：这两部分组成的数据元素ai的数据映像，成为节点。
5. 链表中第一个节点的存储位置叫头指针
6. 链表的最后一个节点的指针为NULL或“^”;
7. 有时会在链表的第一个节点前附设一个节点，成为头结点。头结点的数据域不存储任何信息，头结点的指针域存储指向第一个节点的指针
图为有没有头结点的区别，头指针都存在

链表的读取：（理解：读取最好在第一个元素节点开始读）
范围：1<= i <=ListLength(L)
思路：
1.声明指针p指向链表的第一个节点，初始化j从1开始；

2.当j<i时，就遍历链表，让p向后移动，j+1；

3.假如p等于null，说明第i个节点不存在

4.否则查找成功，返回p指向的数据

时间复杂度为：O（n）；

---

链表的插入：（理解：插入最好在头指针，第一个元素节点前开始读）
范围：1<= i <=ListLength(L)
1. 声明指针 p 指向链表头结点，初始化 j 从 1 开始；

2. 当 j < i 时，就遍历链表，让 p 的指针向后移动，不断指向下一个节点， j 累加 1
3. 若链表末尾 p 为空，则说明第 i 个节点不存在
4. 否则查找成功，在系统中生成一个空节点 s；
5. 将数据元素 e 赋值 给s->data
6. s->next = p->next ; p->next = s;
7 返回成功

操作结果：在 L 中第 i 个节点位置前插入新的数据元素 e ，L 长度加一。

---

链表的删除：（理解：删除最好在头指针，第一个元素节点前开始读）
范围：1<= i <=ListLength(L)
过程：
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 节点
8.返回成功

---

#include "string.h"
#include "ctype.h"

#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"

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

#define MAXSIZE 1000 /* 存储空间初始分配量 */
typedef int ElemType ;
typedef int status  ;

typedef struct Node{
    ElemType data;
    struct Node * next;
}Node;

typedef struct Node* LinkList;


status GetElem(LinkList L ,int i , ElemType *e){  // L 指向头结点 L 叫头指针


    int j;
    LinkList p;
    p = L->next;                               // p 指向元素的第一个节点
    j = 1;
    while(p && j<i){                           // p 向后移动
        p = p ->next;                          // p 指向第二个节点，第三个节点。。。。
                                               // 因为 i+1 个节点不存在,到第 i+1 个节点退出
        ++j;
    }

   // printf("%p",p);

    if(!p || j>i){
        printf("p为空\n");
        return ERROR;

    }

    *e = p->data;

}


status ListInsert(LinkList *L , int i, ElemType e){  // 这里可以改成 LinkList L
                                                    // 因为这里不涉及改变 L 指向的变量


    int j;
    LinkList p,s;
    p = *L;// p 为头指针， p 指向头元素节点
    j = 1;

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

    if(!p || j>i){   // j > i 是防止出现 i=0 的情况
        return ERROR;
    }

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

    s->next = p->next;
    p->next = s;
    return OK ;

}


status InitList(LinkList *L) // 注意这里使用了二级指针 不用一级指针是因为 L 是在栈中新开辟的元素，
                             // 和原 p 指向同一内存地址，而这里修改了 L 的指向的内存空间，但指针 p 还是没有变化，
                            // 还造成了内存泄漏，在堆中申请的内存空间无法访问
{
    *L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使 L 指向此头结点 */
    if(!(*L)) /* 存储分配失败 */
    return ERROR;
    (*L)->next=NULL; /* 指针域为空 */
    return OK;
}


status ListDelete(LinkList *L , int i , ElemType *e){
    LinkList p = *(L);
    LinkList q;
    int j;
    j=1;
    while(p&&j<i){// 遍历寻找 i-1 个节点
        p = p->next;
        ++j;
    }

    if(!(p->next)||j>i){ //因为要删除第 i 个节点，所以看第 i-1的 指针域不能为空
        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;
    }


}

void CreateListTail(LinkList * L ,int n){
    srand(time(0));
    *L= (LinkList)malloc(sizeof(Node));
    LinkList p = *(L); // p 为指向尾部的指针
    LinkList r;
    int i;
    for(i=0;i<n;i++){
        r = (Node *)malloc(sizeof(Node));
        r->data=rand()%100+1;
        p->next = r;
        p = r;
    }
    r->next = NULL;
}


status ClearList(LinkList *L){
    LinkList p,q;
    p=(*L)->next;
    while(p){
        q=p->next;
        free(p);
        p=q;
    }

    (*L)->next = NULL;  // 头节点的指针域为空
    return OK;
}


status ListEmety(LinkList L){
    if(L->next){
        return OK;
    }else{
        return ERROR;
    }
}


int ListLength(LinkList L){
    int i=0;
    L=L->next;
    while(L){
       i++;
       L=L->next;
    }
    return i;
}

/* 初始条件：顺序线性表 L 已存在 */
/* 操作结果：返回 L 中第 1 个与 e 满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为 0 */
int LocateElem(LinkList L,ElemType e)
{  int i=1;
   L=L->next;
   while(L){
        if(L->data == e)
        return i;

        L=L->next;
        i++;
   }
}


int main(){


   int e;
   LinkList p=NULL;
   InitList(&p);
   //printf("%p",p);
   LinkList firstNode = (LinkList)malloc(sizeof(Node));
   p->next = firstNode;
   firstNode->next=NULL;
   firstNode->data=12345;

    ListInsert(&p,1,5);
    ListInsert(&p,2,4);
     ListInsert(&p,3,6);

    ListDelete(&p,3,&e);
   //printf("%d\n",p->next->next->data);
   //GetElem(p,3,&e);
  // printf("%d\n",e);
   int weizhi = LocateElem(p,5);
   printf("5的位置为%d\n",weizhi);

   LinkList L ,L1;
   CreateListHead(&L,10);
   int c =ListLength(L);
   printf(" L 的个数为%d\n",c);

   printf(" L 的元素为\n");
   L=L->next; //最好不用 L 操作，这样的话找不到第一个节点了，如 L1 那样写
   while(L){
    printf("%d\n",L->data);
    L=L->next;
   }

   printf("L1的元素为\n");

   LinkList x;
   CreateListTail(&L1,10);
   x=L1->next;

   while(x){
    printf("%d\n",x->data);
    x=x->next;
   }

   ClearList(&L1);

   printf("清空 L 的指针为%p",L1->next);

return 0;
}