链表基本概念

数据域+指针域构成结点Node
n个结点构成链表
因为每个结点只包含一个指针域，所以叫做单链表

  • 头指针：链表第一个结点的存储位置
  • 头结点：数据域不存东西，指针域存指向第一个结点的指针，即头指针
    头指针是链表的必要元素 而头结点不是，只是为了操作方便
    头指针具有标识作用，常用头指针冠以链表的名字
  • 尾结点：指针域指向NULL的结点

链表代码描述

  1. 若线性表为空表：则头结点的指针域为空
  2. 用结构指针描述结点
typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList;

单链表的读取

单链表中第i个元素的读取 需要从头开始找
获得第i个数据的思路：

  1. 声明结点p指向第一个结点 初始化j=1；
  2. j< i，遍历链表，p不断指向下一个结点 j++;
  3. 若到链表末尾p为空，则第i个元素不存在
  4. 否则查找成功，返回p的数据
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j;
    LinkList p;
    p=L->next; //让p指向L的第一个结点 
    j=1;
    while(p&&j<i)
    {
        p=p->next;
        j++;
    }
    if(!p||j>i)              // j>i的原因？
        return ERROR;
    *e=p->data;
    retrn OK;
}

单链表的插入与删除

单链表的插入

将结点s插入p与p->next之间 即

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

有了头结点之后 在表头和表尾插入 操作是相同的

s->next=L->next;
L->next=s;

s->next=rear->next;
rear->next=s;

如果没有头结点，第一个结点就是存储结点
则表头如下

s->next=first;
first=s;

单链表第i个数据(之前!!!)插入结点的算法

  1. 获取第i-1个元素的工作指针p (遍历链表)
  2. 生成空结点s
  3. 将数据e赋给s
  4. 插入标准语句
  5. 返回成功
Status ListInsert(LinkList *L,int i,ElemType e)
{
    int j;
    LinkList p,s;
    p=*L; //!!!!!!此处与上一个算法不同 插入在第i个元素之前，所以p初始化即为头结点 而非第一个结点
    // p=L;是错误的 因为定义的变量是指针变量 *L 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;

}

此处用到了malloc标准函数，即生成了数据类型是LinkList，大小是Node结构体的一个结点

单链表的删除

删除p结点后结点的想法

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

但是这样没有保留下删除的指针

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

单链表删除第i个结点的算法

  1. 遍历得到第i个结点
  2. 删除标准语句 p->next=q; p->next=q->next;
  3. 将q结点中的数据赋给e
  4. 释放q结点
  5. 返回成功
    注：这里的p结点是删除第i个结点之前的结点
Status ListDelete(LinkList *L,int i,ELemType *e)
{
    LinkList p,q;
    int j;
    ElemType e;
    int j=1;
    p=*L;
    while(p&&j<i)
    {
        p=p->next;
        j++;
    }
    if(!p||j>i)
        return ERROR;
    q=p->next;
    p->next=q->next;
    *e=q->data;
    free(q);
    reutrn OK;
}

单链表的插入和删除都是由两部组成
1.遍历找到第i-1个元素 2.插入和删除元素 因此其时间复杂度都是O(n)!!
但如果需要在同一个位置插入很多个元素，则后续操作都是O(1)，因此对于插入和删除数据越频繁的操作，单链表的优势效率越明显

单链表的整表创建

单链表的创建过程是一个动态生成链表的过程，即从空表依次建立各元素结点，并逐个插入链表
算法思路：

  1. 声明结点p和计数器变量i
  2. 初始化空链表L
  3. 让L的头结点的指针指向NULL
  4. 循环：
  1. 生成一个新节点赋值给p
  2. 生成一个数字赋值给p
  3. 将p插入到头结点与前一新结点之间

头插法

void CreateListHead(LinkList *L,int n)
{
    LinkList p;
    int i;
    srand(time(0)); // 初始化随机数种子
    *L=(LinkList)malloc(sizeof(Node)); // L是动态生成的，其值不断改变
    (*L)->next=NULL;
    for(i=0;i<n;i++)
    {
        p=(LinList)malloc(sizeof(Node));
        p->data=rand()%100+1;//随机生成100以内的数字
        p->next=(*L)->next;
        (*L)->next=p;
    }

}

尾插法

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=(LinkList)malloc(sizeof(Node));
        p->data=rand()%100+1;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}

此处L指的是整个单链表，而r是指向尾结点的变量，r随着循环不断变化结点，L则是增长为多一个结点的链表

Q:

  1. 为什么读取和删除是ElemType *e指针类型的变量？ 插入是ElemTyepe e?
    顺序表：书中代码是伪代码，书中有&的是希望通过函数改变该参数的值。因此新建顺序表，插入删除都有SqList &L,而查找顺序表则是 SqList L
  2. LinkList L,LinkList *L的区别?
  • A:首先声明node结构体，别名为Node,指针类型为LinkList
  • LinkList L; L是指向定义的Node结构体的指针；是单链表类型的单链表
  • LinkList *L; 一般用头指针表示链表类，实质即为该链表的头指针类型
    此时L是指向Node结构体指针的指针 (*L)则是指向Node结构体的指针，因此用->可以访问结构体成员 (**L)则是结构体，可以用.运算符访问结构体成员
  • 如果函数会改变指针L的值，而你希望函数结束调用后保存L的值，那就用LinkList *L,这样向函数传递的是指针的地址，结束调用后即可改变指针的值。
  • 如果函数只修改指针所指向的内容，而不变更指针的值，那么用LinkList L

在头插法，尾插法中单链表L改变了所以用 前者

单链表的整表删除

当不使用单链表时，将其在内存中释放

  1. 声明p和q
  2. 将第一个结点赋给p
  3. 循环：
  1. 将下一个结点赋给q；
  2. 释放p；
  3. 将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;
}