链表

最新推荐文章于 2022-12-10 16:05:09 发布
最新推荐文章于 2022-12-10 16:05:09 发布
阅读量760 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/strange_stv/article/details/114444620
版权

文章目录

这学期这门程序设计基础一组合后变难了。这篇文章将PPT内容移植过来，方便阅读

数据结构的一些基本概念

计算机应用中，数值、文字、图形、图像、声音等各种形式的信息是对客观事物的符号化编码表示，也称为数据（data）。

构成数据的、具有相同性质的基本单元称为数据元素（data element）。

数据项（data item）是构成数据的相对独立的分项，它反映客观事物的某种特性。

性质相同的数据元素集合组成数据对象（data object）。

如出版社图书信息管理系统中已出版图书列表，每本书的信息是一个数据元素，由书名、作者、定价信息、出版时间等多个数据项组成。所有这些数据元素构成数据对象，表示该出版社出版的所有图书。

数据对象内的数据元素间可以存在一种或多种关系。数据结构(data structure)是相互之间存在一种或多种特定关系的数据元素的集合，包含数据对象和关系两个组成部分。

数据结构可以用二元组来表示：

Data Structure = (D, S)

其中

在这里插入图片描述

逻辑结构基本概念

用二元组描述的数据结构体现出数据元素间的逻辑关系，称为逻辑结构

4种基本逻辑结构：线性结构、集合结构、树型结构和图状结构

数据结构只有在计算机物理存储器上存储表示后，才能设计程序进行处理，数据结构在计算机物理存储器里的实际存储方案称为存储结构。存储结构需要存储（表示）数据对象和数据元素间的各种关系。

同一种逻辑结构，可以采用不同的存储结构。通常采用两种存储结构：

顺序存储结构。所有数据元素在内存空间中依次存放，数据元素在物理存储器上的位置关系体现了它们在逻辑上的关系，通常用于表示简单的顺序关系。
链式存储结构。数据元素分散存放，在存放每个数据元素时，必须附加一个或若干专门的数据项来指示其它相关联的数据元素在存储器中的存放位置。

在这里插入图片描述

线性表

线性表的定义

在这里插入图片描述

线性表是n个数据元素的有限序列，可记为：在这里插入图片描述n是线性表的长度。当n = 0时，为一空表。

线性表的抽象数据类型表示

数据类型（data type）和抽象数据类型（abstract data type, ADT）

在这里插入图片描述

线性表的抽象数据类型定义

 ADT List {  
 基本操作：
    创建空表Create () ;       //创建一个空的线性表
    清空Clear (L) ;           //将已有线性表L清空
    销毁线性表Destroy (L);    //销毁一个线性表L，不再使用
    拷贝线性表Copy (L) ;      //根据已有线性表L，复制一个新线性表，内容相同
    判空IsEmpty (L) ;         //判断线性表L是否为空表，若是则返回TRUE，否则返回FALSE
    求长度Length (L);         //返回线性表中数据元素的个数
    获取起始位置BeginPosition (L) ;  //返回线性表中代表第一个元素的位置
			                        //空表返回EndPosition (L)
    获取结束位置EndPosition (L);   //返回代表线性表结束的位置
    迭代下一位置NextPosition (L,pos); //返回线性表中pos有效位置的下个位置
			                         //结束位置返回EndPosition (L)
    获取元素位置LocatePosition (L,i);  //返回线性表代表第i个元素所在位置，1≤i≤n
                                      //（设线性表的表长为n）
    定位元素位置LocateElem(L,e) ; //根据数据元素e查找它在线性表中出现的位置
                                 //若存在，则返回它的有效位置；否则返回EndPosition (L)
    获取元素GetElem (L,pos) ;   //返回线性表中pos有效位置的数据元素
    设置元素SetElem (L,pos,e);  //将线性表中pos有效位置的数据元素设置为e
    插入元素InsertBefore (L,pos,e); //在线性表的pos位置前插入一新的数据元素
                                   //pos为EndPosition (L)时添加在尾部
    删除元素Delete(L,pos) ;        //删除线性表中pos有效位置所在数据元素
}

线性表的顺序储存

用一组地址连续的存储单元依次存放线性表中的数据元素。
在这里插入图片描述

线性表中任意一个数据元素的存储位置都可以用线性表中第一个数据元素a1的存储地址加上偏移表示。其中：K为一个数据元素所占存储量。

在这里插入图片描述

线性表抽象数据类型List可以采用顺序存储结构实现。

线性表的顺序表示声明模块SeqList.h

#ifndef __SEQLIST_H_INCLUDED_
#define __SEQLIST_H_INCLUDED_
typedef  int DataElem;    //假设元素类型为整型
//线性表类型
struct SeqList {
    DataElem *pDatas;   //存放元素表的缓冲区指针
    int       iLength;  //线性表长度
    int       iSize;    //缓冲区大小
};
typedef  DataElem *  Position;    //线性表中位置类型
//...在此省略线性表各基本操作的函数声明
#endif // __SEQLIST_H_INCLUDED_

线性表顺序表示基本操作

1. 创建空线性表
//建立一个最多可存放iSize个元素的空线性表，失败时缓冲区指针为NULL
struct SeqList Create (int iSize)
{   struct SeqList list;
   //申请存放线性表元素的连续内存空间
   list.pDatas = (DataElem *)malloc (iSize * sizeof (DataElem));
   list.iLength = 0;
   list.iSize = iSize;
   if (list.pDatas == NULL) {//申请不到空间
       list.iSize = 0;
   }
   return list;
}
2. 线性表清空
//元素个数置为0
void Clear (struct SeqList *pSeqList)
{
    pSeqList->iLength = 0;
}
3. 销毁一个线性表，不再使用，释放缓冲区
void Destroy (struct SeqList *pSeqList)
{
    free (pSeqList->pDatas);                  //释放缓冲区
    pSeqList->pDatas = NULL;
    pSeqList->iSize = 0;
}
4. 根据已有线性表，复制一个内容相同的新线性表
 //返回复制后新线性表，失败时返回线性表的头指针为NULL
 struct SeqList Copy (struct SeqList srcSeqList)
{   struct SeqList destSeqList;
    destSeqList = Create (srcSeqList.iSize); //创建一个具有相同大小缓冲区的空线性表
    if (destSeqList.pDatas == NULL)
        return destSeqList;  //创建失败时直接返回
    int i;
    for (i = 0; i < srcSeqList.iLength; ++i) //复制所有元素
        destSeqList.pDatas [i] = srcSeqList.pDatas [i];
    destSeqList.iLength = i; //设置线性表长度
    return destSeqList; //返回复制完的线性表
}
5. 线性表判空
int IsEmpty (struct SeqList list)
{
    return (list.iLength == 0);
}
6. 线性表求长度
int Length (struct SeqList list)
{
    return list.iLength;
}
7. 获取起始位置
//返回线性表中代表第一个元素的位置，空表返回EndPosition (L)
Position BeginPosition (struct SeqList list)
{
    return list.pDatas;
}
8. 获取结束位置
//返回代表线性表结束的位置
Position  EndPosition (struct SeqList list)
{
    return list.pDatas + list.iLength;
}
9. 迭代下一位置
//返回线性表中p有效位置的下个位置，主要用于循环遍历线性表
Position NextPosition (struct SeqList list, Position  pos)
{
    return pos+1;
}
10. 获取元素位置
//返回线性表代表第i个元素所在位置，1≤i≤n（设线性表的表长为n）
Position LocatePosition (struct SeqList list, int i)
{
    if (i >= 1 && i <= list.iLength)
        return list.pDatas + (i - 1);
    return list.pDatas + list.iLength; //超出范围，返回结束位置
}
11. 定位元素位置
//根据数据元素e查找它在线性表中出现的位置，若存在，则返回它的有效位置；
//否则返回EndPosition (L)
Position LocateElem (struct SeqList list, DataElem e)
{
    int  i;
    for (i = 0; i < list.iLength; ++i)
        if (list.pDatas [i] == e) //查找到
            return list.pDatas + i;
    return list.pDatas + list.iLength; //超出范围，返回结束位置
}
12. 获取元素
//返回线性表L中pos有效位置的数据元素
DataElem GetElem (struct SeqList list, Position  pos)
{
    assert (pos != EndPosition (list)); //断言，包含头文件assert.h
    return *pos;
}
13. 设置元素
//将线性表中pos有效位置的数据元素设置为e
void SetElem (struct SeqList list, Position  pos, DataElem e)
{
    assert (pos != EndPosition (list)); //断言，包含头文件assert.h
    *pos = e;
}
14. 插入元素
//在线性表的pos位置前插入一新的数据元素，
//pos为EndPosition (L)时添加在尾部，线性表长度加1
//成功时返回1，失败时返回0
int InsertBefore (struct SeqList *pSeqList, Position  pos, DataElem e)
{    if (pSeqList->iSize == pSeqList->iLength) {//空间已满，先扩充空间
        struct SeqList newSeqList = Create (2 * pSeqList->iSize); //建立2倍空间的临时线性表
        if (newSeqList.pDatas == NULL) {
             return 0; //申请不到空间，操作失败
        }
        int i;
        for (i = 0; i < pSeqList->iLength; ++i) //复制所有元素
             newSeqList.pDatas [i] = pSeqList->pDatas [i];
        newSeqList.iLength = i; //设置线性表长度   （待续）
        pos = newSeqList.pDatas + (pos - pSeqList->pDatas); //原pos必须更新
        Destroy(pSeqList);       //销毁原线性表，板卡它的缓冲区，避免内存泄漏
        *pSeqList = newSeqList;  //用扩充空间后线性表代替原线性表
    }
    assert (pSeqList->iSize > pSeqList->iLength); //线性表内存空间必有空余
    Position  lastPos = pSeqList->pDatas+pSeqList->iLength; //线性表后空余位置
    while (pos != lastPos) { //从后往前循环后移，直到到达指定位置
        *lastPos = *(lastPos-1); //元素后移一个位置
        --lastPos;               //准备处理前一位置元素
    }
    *pos = e;           //将元素存入已空出位置
    ++pSeqList->iLength; //调整线性表长度
    return 1;
}
15. 删除元素
//删除线性表中pos有效位置所在数据元素，线性表的表长减1
void Delete (struct SeqList *pSeqList, Position  pos)
{
    Position  endPos = EndPosition (*pSeqList);
    assert (pos != endPos); //断言，包含头文件assert.h
    ++pos; //后移一位置
    while (pos!= endPos) {
        *(pos - 1) = *pos; //后一位置元素前移
        ++pos;           //准备后移下一个元素
    }
    --pSeqList->iLength; //调整线性表长度
}
16、通过抽象数据类型SeqList的基本操作打印线性表
void Print (struct SeqList list)
{   printf ("(");
    Position pos = BeginPosition(list);
    if (pos != EndPosition(list)) {
        printf ("%d", GetElem (list, pos));
        pos = NextPosition(list, pos);
    }
    while (pos != EndPosition(list)) {
        printf (",%d", GetElem (list, pos));
        pos = NextPosition(list, pos);
    }
    printf (")\n");
}
主函数
int main()
{   int i;
    struct SeqList  list = Create (1);       //创建一个空线性表
    Print (list);  //打印线性表
    for (i = 1; i <=5; ++i)//尾部循环插入i
        InsertBefore (&list, EndPosition(list), i);
    Print (list);
    Position pos = LocateElem(list, 3); //查找元素3
    if (pos != EndPosition(list))    Delete (&list, pos); //查找到元素时，删除元素
    InsertBefore (&list, BeginPosition(list), 8); //头部插入元素8
    Print (list);
    Destroy (&list); //销毁线性表，避免内存泄漏
    return 0;
}

线性表的链式存储

采用链式存储结构，有利于线性表的插入、删除操作，每个结点中只有一个“链”时，称为单链表，每个结点中有两个“链”时，称为双向链表。“链”通常用指针来表示，线性表的链式存储结构也是实现复杂数据结构的基础。

单链表的概念

在这里插入图片描述
一般结点类型定义如下：

struct Node {
	DataElem  data;
	struct Node *next;
};
struct Node    *p， *q; //声明指针型变量p、q

注意事项有：
特别需要注意指针变量p和p所指结点的区别。指针变量p和p所指结点是独立存在的
当p是空指针时，禁止通过空指针访问结点内数据域或指针域
通过非空指针变量p可访问结点的数据域p->data和指针域p->next
p->data和p->next既可作为右值、又可作为左值出现在表达式中。右值和左值是表达式中语法单位，意味着可出现在赋值运算符右边和左边
p->next还是一个指针，只要它非空，可以继续通过它访问所指结点的数据域和指针域，如p->next->data和p->next->next
指针变量p未初始化时，不可访问p->next或p->data，否则，可能造成程序崩溃
C/C++语言中，动态分配的结点必须释放，否则造成内存泄漏

常见的指针操作及其效果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

对结点的基本操作

线性表中插入元素时，需要在链表中增加结点，用下述语句动态分配：

p = (struct Node *) malloc (sizeof (struct Node));

动态分配失败时，返回空指针（NULL），现代面向对象程序设计语言中，如C++，一般按异常处理。
下列语句完成将p所指结点插入q所指结点后:

p->next = q->next; //p后继结点设为原q后继结点
q->next = p;            //q后继结点设为p

下列语句删除p所指结点后继结点:

q = p->next;                       //保存后继结点指针
p->next = q->next;            //链表中去除q所指结点
free (q);                               //释放q所指结点

单链表实现ADT List

在这里插入图片描述

链表结点类型
struct Node {
    DataElem  data;
    struct Node *next;
};
线性表类型
struct List {
    struct Node *pHead;
    struct Node *pTail;
};
typedef  struct Node *  Position;    //线性表中位置类型
1. 创建空线性表
//空表管理的单链表只有一个头结点，失败时首尾指针为NULL
struct List Create ()
{
    struct List list;
    //申请一个结点
    list.pHead = list.pTail = (struct Node *)malloc (sizeof (struct Node));
    if (list.pHead != NULL)
        list.pHead->next = NULL; //后续无结点
    return list;
}
2. 线性表清空
//释放链表中除头结点外所有结点
void Clear (struct List *pList)
{   struct Node *p = pList->pHead->next; //从头结点后结点开始删除
    while (p != NULL) {     //直到最后
        struct Node *q = p; //记住要释放结点
        p = p->next;        //准备释放下一个
        free (q);           //释放结点，释放后不可再访问结点
    }
    pList->pHead->next = NULL; //头结点后已无结点
    pList->pTail = pList->pHead;
}
3. 销毁一个线性表，不再使用，释放所有结点
//传入链首指针变量的地址，销毁单链表
void Destroy (struct List *pList)
{
    Clear (pList);                        //单链表清空
    free (pList->pHead);           //释放最后剩余的头结点
    pList->pHead = pList->pTail = NULL; //将线性表中指针变量置空
}
4. 根据已有线性表，复制一个内容相同的新线性表
//传入原线性表，复制原线性表中链表作为新线性表的链表，
//返回复制后新线性表，失败时返回线性表的头指针为NULL，
struct List Copy (struct List srcList)
{   struct List destList;
    destList = Create (); //创建带头结点的空单链表
    if (destList.pHead == NULL)
        return destList;  //创建失败时直接返回
    struct Node  *p;
    p = srcList.pHead->next; //跳过原链表头结点
    while (p != NULL) {//循环处理原链表
        struct Node *s;
        s = (struct Node *)malloc (sizeof (struct Node));//分配新结点
   （待续）
    if (s == NULL) {
            Destroy (&destList); //申请失败时销毁线性表，避免内存泄漏
            return destList;
        }
        s->data = p->data; //复制元素
        destList.pTail->next = s; //挂在新链表最后
        s->next = NULL; //后面无结点
        destList.pTail = s;       //最后一个结点已变化
        p = p->next;    //准备复制下个结点
    }
    return destList; //返回复制完的线性表
}
5. 线性表判空
判断线性表是否为空表，若是则返回1，否则返回0
int IsEmpty (struct List list)
{
    return (list.pHead->next == NULL); //头结点后无结点
}
6. 线性表求长度
返回线性表中数据元素的个数
int Length (struct List list)
{
    int iCount = 0;
    struct Node *p = list.pHead->next; //从头结点后结点开始计数
    while (p != NULL) {     //直到最后
        ++iCount;
        p = p->next;        //临时变量移至下一结点
    }
    return iCount;
}
7. 获取起始位置
//返回线性表中代表第一个元素的位置，空表返回EndPosition (L)
Position BeginPosition (struct List list)
{
    return list.pHead;
}
8. 获取结束位置
//返回代表线性表结束的位置
Position  EndPosition (struct List list)
{
    return list.pTail;
}
9. 迭代下一位置
//返回线性表中p有效位置的下个位置，主要用于循环遍历线性表
Position NextPosition (struct List list, Position  pos)
{
    return pos->next;
}
10. 获取元素位置
//返回线性表代表第i个元素所在位置，1≤i≤n（设线性表的表长为n）
Position LocatePosition (struct List list, int i)
{
    Position  pos = list.pHead; //从头结点开始
    while (--i> 0 && pos->next != NULL) {//计数完成或直到结束
        pos = pos->next;        //移至下一结点
    }
    return pos;
}
11. 定位元素位置
//根据数据元素e查找它在线性表中出现的位置，若存在，则返回它的有效位置；
//否则返回EndPosition (L)
Position LocateElem (struct List list, DataElem e)
{
    Position  pos = list.pHead; //从头结点开始
    while (pos->next != NULL && pos->next->data != e) {
        pos = pos->next;        //移至下一结点
    }
    return pos; //返回元素所在结点的前一个结点指针
}
12. 获取元素
//返回线性表L中pos有效位置的数据元素
DataElem GetElem (struct List list, Position  pos)
{   assert (pos != EndPosition (list)); //断言，包含头文件assert.h
    return pos->next->data;
}
13. 设置元素
//将线性表中pos有效位置的数据元素设置为e
void SetElem (struct List list, Position  pos, DataElem e)
{   assert (pos != EndPosition (list)); //断言，包含头文件assert.h
    pos->next->data = e;
}

####14. 插入元素

//在线性表的pos位置前插入一新的数据元素，
//pos为EndPosition (L)时添加在尾部，线性表长度加1
//成功时返回1，失败时返回0
int InsertBefore (struct List *pList, Position  pos, DataElem e)
{   struct Node *s = (struct Node *)malloc (sizeof (struct Node));//分配新结点
    if  (s == NULL)  return 0;
    s->data = e;
    s->next = pos->next; //插入在pos所指结点后
    pos->next = s;
    if (pList->pTail == pos)
        pList->pTail = s; //插入在线性表最后时，调整尾结点指针
    return 1;
}
15. 删除元素
//删除线性表中pos有效位置所在数据元素，线性表的表长减1
void Delete (struct List *pList, Position  pos)
{   assert (pos != EndPosition (*pList)); //断言，包含头文件assert.h
    struct Node *s = pos->next; //待删除结点
    pos->next = s->next;        //链表中删除结点
    free (s);                 //释放结点
    if (pList->pTail == s)
        pList->pTail = pos; //删除线性表最后一个结点时，调整尾结点指针
}

采用单链表实现ADT List的测试用例与采用顺序存储结构实现ADT List的测试用例基本相同，只是类型名称不同，输出结果也相同

# 总结 提示：这里对文章进行总结： 例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
Rutela
关注
专栏目录
C语言链表操作详解
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
链表的类型
qq_43078445的博客
03-14 3433
1.单链表 所谓的单链表就是链表最基本的结构，链表通过指针将一组零散的内存块串联在一起，其中，我们把内存块称为链表的“节点”。为了所有的节点能串起来，每个链表的节点除了存储数据之外，还需要激励链表上的下一个节点的地址，如图所示，我们把这个记录下个节点的地址的指针叫做后继指针next,如果链表中某个节点为p，p的下一个节点为q，我们可以描述为：p->next=q 下面的图更加详细的描述了单链表...
链表的定义和使用
meini32的博客
08-09 1281
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。//通俗的说：链表就是由一个个节点组成，这些节点逻辑上连续，物理上不连续）每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。每一个节点由两部分组成，一个是数据域一个是指针域；...
【数据结构】链表定义及其常用的基本操作（C/C++）
EWEADN
12-10 3176
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
数据结构（一）线性链表、非线性链表、稀疏数组与队列、单向链表
codinglover5的博客
08-07 3368
数据结构和算法的关系 ➢数据data结 构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了 数据结构.学好数据结构可以编写出更加漂亮更加有效率的代码。 ➢要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决. ➢程序=数据结构+算法 ➢数据结构是算法的基础，换言之，想要学好算法，需要把数据结构学到位。 线性链表和非线性链表 数据结构包括:线性结构和非线性结构。 线性结构 1)线性结构作为最常用的数据结构，其特点是数据元素之间存在- -对- - 的线性关系（a[0]=3
顺序表(SequenceList)数据结构的基本操作实现详解
HenryBlog
08-17 4648
目录一、前言二、整体设计框架三、函数实现四、完整代码 一、前言 数据结构非常之多，后续小编会逐个更新，简单的存储数据一般有顺序表，链表（单链表和双链表），串等 创建完数据结构后不仅要存储数据，以后还需要查找数据，如果高效的进行查找也需要搜索树，哈希表等这样的结构来实现 有很多人有这样一个疑问：是先学数据结构还是先学算法？ 其实数据结构和算法是不分家的，数据结构中包含一些算法，有些算法的解决又离不开数据结构，比如实现Dijkstra最短路径问题是基于Graph的数据结构实现的 二、整体设计框架 实现顺序表，
PTA 两个有序链表序列的合并
最新发布
10-07
在编程领域，有序链表序列的合并是一个常见的问题，尤其在数据结构和算法的学习中占有重要地位。这个题目“PTA 两个有序链表序列的合并”主要涉及到链表的操作和合并策略，这对于理解和掌握链表操作有极大的帮助。...
07丨链表（下）：如何轻松写出正确的链表代码？1
08-03
【链表】是一种重要的数据结构，它不像数组那样在内存中连续存储，而是通过节点间的指针连接起来。链表的每个节点包含数据和指向下一个节点的指针，这种结构使得链表在插入和删除操作上相比数组更具优势，但同时也...
链表填空题（打印）1
08-08
【链表基础知识】 链表是一种线性数据结构，与数组不同，它不连续存储数据，而是通过节点间的指针连接。每个节点包含数据部分和一个指向下一个节点的指针。链表分为单向链表、双向链表和循环链表等类型。 1. **...
Python单向链表和双向链表原理与用法实例详解
09-20
链表是一种重要的数据结构，它不同于数组，不连续存储元素，而是通过节点之间的引用关系连接。在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只...
python算法题 链表反转详解
01-20
链表的反转是一个很常见、很基础的数据结构题，输入一个单向链表，输出逆序反转后的链表，如图：上面的链表转换成下面的链表。实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
链表的基本概念
想要成为大佬的彪彪
08-23 1111
目录链表的定义链表的结构单向不带头非循环链表(重点掌握，面试常考)单向带头非循环链表单向带头循环链表自己实现一个链表 链表的定义 ​​​ 链表就像每个节点串起来一样构成了一串，每个节点都是一个节点对象 其中我们对于每个节点会去划分域，分为data域跟next域两种. data代表数值域，next代表引用，用于存取下一个节点的地址. 链表的结构 单向不带头非循环链表(重点掌握，面试常考) 单向带头非循环链表 单向带头循环链表 自己实现一个链表 ...
链表的定义和操作
sin_0119的博客
10-05 4369
链表的定义和操作
【数据结构】使用Java实现顺序表类 SeqList
qq_41427568的博客
04-17 6695
目录线性表介绍顺序表介绍Java->顺序表APIJava->顺序表代码 线性表介绍 数据结构中的线性存储结构分为两大类：顺序存储和链式存储，顺序存储对应的是顺序表，链式存储对应的是链表。这篇文章主要介绍如何使用Java实现一个顺序表。 顺序表介绍 顺序表： 把线性表的元素按照一定逻辑顺序依次放在一组地址连续的存储单元里，用这种方式存储的线性表简称为 顺序表。而链表中的元素是没有放在一组...
【数据结构】链表
鑫仔的记忆
09-30 2246
链表
链表基础知识和相关操作
qq_43697646的博客
01-04 1169
一、链表的类型 1.单链表 入口点为链表的头结点(head)，链表中每个节点存储该结点的内容(数据)以及下一个节点的指针。 2.双链表 每个节点有两个指针域，一个指向该结点前一节点，另一个指向该结点后一节点，此种链表既可向前查询也可以向后查询。 3.循环链表 即链表首尾相连，可用于解决约瑟夫环问题。 二、链表在内存的存储 数组在内存中是以连续空间存储，链表在内存中并不是连续存储，而是散落分布在内存中，通过指针串联各个节点。 三、链表的定义 struct ListNode{
链表基础与单向链表解析
"链表是一种动态数据结构，与数组相比，它允许在程序运行时根据需要增加或减少元素，克服了数组预设长度和插入删除效率低的问题。链表主要由节点组成，每个节点包含数据域和指针域，指针域指向下一个节点。单向链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值