单链表(c语言）

最新推荐文章于 2024-06-07 22:14:23 发布

ともりなお

最新推荐文章于 2024-06-07 22:14:23 发布

阅读量106

点赞数

文章标签： c语言链表数据结构

本文链接：https://blog.csdn.net/weixin_48086091/article/details/129621459

版权

链表基本概念

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

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

链表代码描述

若线性表为空表：则头结点的指针域为空
用结构指针描述结点

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

单链表的读取

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

声明结点p指向第一个结点初始化j=1；
j< i，遍历链表，p不断指向下一个结点 j++;
若到链表末尾p为空，则第i个元素不存在
否则查找成功，返回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个数据(之前!!!)插入结点的算法

获取第i-1个元素的工作指针p (遍历链表)
生成空结点s
将数据e赋给s
插入标准语句
返回成功

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个结点的算法

遍历得到第i个结点
删除标准语句 p->next=q; p->next=q->next;
将q结点中的数据赋给e
释放q结点
返回成功
注：这里的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)，因此对于插入和删除数据越频繁的操作，单链表的优势效率越明显

单链表的整表创建

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

声明结点p和计数器变量i
初始化空链表L
让L的头结点的指针指向NULL
循环：
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:

为什么读取和删除是ElemType *e指针类型的变量？插入是ElemTyepe e?
顺序表：书中代码是伪代码，书中有&的是希望通过函数改变该参数的值。因此新建顺序表，插入删除都有SqList &L,而查找顺序表则是 SqList L
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改变了所以用前者

单链表的整表删除

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

声明p和q
将第一个结点赋给p
循环：
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;
}