数据结构学习之路-第二章：静态单链表

最新推荐文章于 2023-03-15 23:15:54 发布
最新推荐文章于 2023-03-15 23:15:54 发布
阅读量818 收藏 2
点赞数
分类专栏： 数据结构学习之路 数据结构学习之路 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/libin1105/article/details/48026229
版权

【 声明：版权所有，转载请标明出处，请勿用于商业用途。  联系信箱：libin493073668@sina.com】


前言：

对于指针构造单链表的方法，我们在之前那篇博客里已经学完了，但是我们知道，指针是C/C++特有的神器，那么对于没有指针的其他语言，又该怎么去模拟链表呢？我们就需要使用静态链表的思想了。

接下里我们将要学习的就是如何不用指针来完成单链表的创建与操作。


注：

本文仅代表博主本人的一些浅显的见解，欢迎大家评论学习，共同创造出一个良好的环境

对于一些问题，博主会尽量为大家解答，但是如果有疑问没有及时回答的，也希望其他热心人心帮忙解决，鄙人不胜感激


静态单链表


1.存储结构

首先我们要开一个足够大的结构体数组，单个结构体就表示一个结点，里面要保存两个元素，其中一个是数据data，而另外一个则是代替指针而存在的“游标”cur，这个cur就像指针型的链表的next指针一样，我们要遍历这个链表就得靠它了。

#define MAXSIZE 1000  //链表的最大长度
typedef struct
{
    ElemType data;    //数据
    int cur;          //游标
} component,SLinkList[MAXSIZE];


2.分配与释放

我们知道，在指针型的链表之中，我们可以通过库函数的malloc与free函数来动态分配与释放内存，但是这对于静态链表的cur是不适用的，事实上我们并没有指针那种完全的自由，我们的操作必须还是在指定大小的数组内进行，最笨的方法就是每次人工判断是否为空闲节点，但是这种方法显然是不符合实际的，为了解决这个问题，我们可以将这个链表分为两个部分。一个部分是已经保存了数据的数据链表，另外一个则是还没有数据的备用链表，我们以位置0为备用链表的表头，以MAXSIZE-1为数据链表的表头。那么当我们需要新节点的时候，就把备用链表中的第一个节点删除，作为新结点。当删除数据链表中的结点的时候，就把删除的结点插入备用链表中成为备用链表的第一个结点。

int Malloc(SLinkList L)
{
    //操作结果：若备用链表非空,则返回分配的结点下标(备用链表的第一个结点),否则返回0
    int i = L[0].cur;
    if(L[0].cur)     //备用链表非空
        L[0].cur = L[i].cur;   //备用链表的头结点指向原备用链表的第二个结点,那么第一个结点则脱离了备用链表，返回其位置，作为数据链表将要插入的新结点
    return i;        //返回新开辟结点的坐标
}


void Free(SLinkList L,int k)
{
    //操作结果：将下标为k的空闲结点回收到备用链表(成为备用链表的第一个结点)
    L[k].cur = L[0].cur;   //回收结点的＂游标＂指向备用链表的第一个结点
    L[0].cur = k;          //备用链表的头结点指向新回收的结点
}

3.创建、插入、删除

在完成了开辟空间与释放空间的基础之上，我们应该已经了解到现在这个静态链表的操作是怎么一回事了，那么接下来完成这三个操作就手到擒来了。

void InitList(SLinkList L)
{
    //操作结果：构造一个空的链表，表头为L的最后一个单元L[MAXSIZE-1]，其余单元链成一个备用链表，表头为L的第一个单元L[0]，“0”表示空指针
    int i;
    L[MAXSIZE-1].cur = 0;          //L的最后一个单元为空链表的表头
    for(i = 0; i<MAXSIZE-2; i++)   //将其余单元链接成以L[0]为表头的备用链表
        L[i].cur = i+1;
    L[MAXSIZE-2].cur = 0;
}

Status ListInsert(SLinkList L,int i,ElemType e)
{
    //操作结果：在L中第i个元素之前插入新的数据元素e
    int l,j,k = MAXSIZE-1;       //k指向表头
    if(i<1||i>ListLength(L)+1) return ERROR;
    j = Malloc(L);               //申请新单元
    if(j)                        //申请成功
    {
        L[j].data = e;           //赋值给新单元
        for(l = 1; l<i; l++)     //找到第i-1个元素的位置
            k = L[k].cur;
        L[j].cur = L[k].cur;     //改变指针，大家可以回忆一下指针链表的插入过程
        L[k].cur = j;
        return OK;
    }
    return ERROR;
}

Status ListDelete(SLinkList L,int i,ElemType *e)
{
    //操作结果：删除在L中第i个数据元素e，并返回其值
    int j,k = MAXSIZE-1;       //k指向表头
    if(i<1||i>ListLength(L)) return ERROR;
    for(j = 1; j<i; j++)       //找到第i-1个元素的位置
        k = L[k].cur;
    j = L[k].cur;              //改变指针，大家可以回忆一下指针链表的删除过程
    L[k].cur = L[j].cur;
    *e = L[j].data;
    Free(L,j);
    return OK;
}


4.其他操作

其他的操作我也就不用再多做解释了，一切都是在指针形式的单链表中修改过来的，只要理解了静态链表的原理，要做出相应的修改也不是很难，具体解释已经都在注释中了，大家可以试着自己去理解，如果还有不懂的也欢迎提问。

Status ClearList(SLinkList L)
{
    //初始条件：线性表L已存在。
    //操作结果：将L重置为空表，把原本的备用链表接到原本的数据链表后面，作为一整条新的备用链表
    int i,j,k;
    i = L[MAXSIZE-1].cur;   //链表第一个结点的位置
    L[MAXSIZE-1].cur = 0;   //链表置为空表
    k = L[0].cur;           //备用链表第一个结点的位置
    L[0].cur = i;           //把链表的结点连到备用链表的表头
    while(i)                //没到链表尾
    {
        j = i;
        i = L[i].cur;       //指向下一个元素
    }
    L[j].cur = k;           //备用链表的第一个结点接到链表的尾部
    return OK;
}

Status ListEmpty(SLinkList L)
{
    //操作结果：若L是空表，返回TRUE；否则返回FALSE
    return L[MAXSIZE-1].cur==0;
}

int ListLength(SLinkList L)
{
    //操作结果：返回L中数据元素个数
    int j = 0,i = L[MAXSIZE-1].cur;  //i指向第一个元素
    while(i)                         //没到静态链表尾
    {
        i = L[i].cur;                //指向下一个元素
        j++;
    }
    return j;
}

Status GetElem(SLinkList L,int i,ElemType *e)
{
    //操作结果：用e返回L中第i个元素的值
    int l,k = MAXSIZE-1;          //k指向表头序号
    if(i<1||i>ListLength(L)) return ERROR;
    for(l = 1; l<=i; l++)   //移动到第i个元素处
        k = L[k].cur;
    *e = L[k].data;
    return OK;
}

int LocateElem(SLinkList L,ElemType e)
{
    //操作结果：在静态单链线性表L中查找第1个值为e的元素。若找到，则返回它在L中的位序，否则返回0。
    int i = L[MAXSIZE-1].cur;  //i指示表中第一个结点
    while(i&&L[i].data!=e)     //在表中顺链查找
        i = L[i].cur;
    return i;
}

Status PriorElem(SLinkList L,ElemType cur_e,ElemType *pre_e)
{
    //初始条件：线性表L已存在
    //操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义
    int j,i = L[MAXSIZE-1].cur;   //i指示链表第一个结点的位置
    do
    {
        j = i;
        i = L[i].cur;             //向后移动结点
    }
    while(i&&L[i].data!=cur_e);
    if(i)                         //找到该元素
    {
        *pre_e = L[j].data;
        return OK;
    }
    return ERROR;
}

Status NextElem(SLinkList L,ElemType cur_e,ElemType *next_e)
{
    //初始条件：线性表L已存在
    //操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，否则操作失败，next_e无定义
    int j,i = LocateElem(L,cur_e);//在L中查找第一个值为cur_e的元素的位置
    if(i)                         //L中存在元素cur_e
    {
        j = L[i].cur;             //cur_e的后继的位置
        if(j)                     //cur_e有后继
        {
            *next_e = L[j].data;
            return OK;            //cur_e元素有后继
        }
    }
    return ERROR;                 //L不存在cur_e元素,cur_e元素无后继
}

Status ListTraverse(SLinkList L,void (*vi)(ElemType))
{
    //初始条件:线性表L已存在
    //操作结果:依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败
    int i = L[MAXSIZE-1].cur;   //指向第一个元素
    while(i)                    //没到静态链表尾
    {
        vi(L[i].data);          //调用vi()
        i = L[i].cur;           //指向下一个元素
    }
    printf("\n");
    return OK;
}

5.具体测试

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
#include <ctype.h>
#include <malloc.h>
#include <limits.h>
#include <stdlib.h>
#include <io.h>
#include <process.h>
using namespace std;

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

typedef int ElemType;
typedef int Status;

#define MAXSIZE 1000  //链表的最大长度

typedef struct
{
    ElemType data;    //数据
    int cur;          //游标
} component,SLinkList[MAXSIZE];

int Malloc(SLinkList L)
{
    //操作结果：若备用链表非空,则返回分配的结点下标(备用链表的第一个结点),否则返回0
    int i = L[0].cur;
    if(L[0].cur)     //备用链表非空
        L[0].cur = L[i].cur;   //备用链表的头结点指向原备用链表的第二个结点,那么第一个结点则脱离了备用链表，返回其位置，作为数据链表将要插入的新结点
    return i;        //返回新开辟结点的坐标
}


void Free(SLinkList L,int k)
{
    //操作结果：将下标为k的空闲结点回收到备用链表(成为备用链表的第一个结点)
    L[k].cur = L[0].cur;   //回收结点的＂游标＂指向备用链表的第一个结点
    L[0].cur = k;          //备用链表的头结点指向新回收的结点
}

void InitList(SLinkList L)
{
    //操作结果：构造一个空的链表，表头为L的最后一个单元L[MAXSIZE-1]，其余单元链成一个备用链表，表头为L的第一个单元L[0]，“0”表示空指针
    int i;
    L[MAXSIZE-1].cur = 0;          //L的最后一个单元为空链表的表头
    for(i = 0; i<MAXSIZE-2; i++)   //将其余单元链接成以L[0]为表头的备用链表
        L[i].cur = i+1;
    L[MAXSIZE-2].cur = 0;
}

Status ClearList(SLinkList L)
{
    //初始条件：线性表L已存在。
    //操作结果：将L重置为空表，把原本的备用链表接到原本的数据链表后面，作为一整条新的备用链表
    int i,j,k;
    i = L[MAXSIZE-1].cur;   //链表第一个结点的位置
    L[MAXSIZE-1].cur = 0;   //链表置为空表
    k = L[0].cur;           //备用链表第一个结点的位置
    L[0].cur = i;           //把链表的结点连到备用链表的表头
    while(i)                //没到链表尾
    {
        j = i;
        i = L[i].cur;       //指向下一个元素
    }
    L[j].cur = k;           //备用链表的第一个结点接到链表的尾部
    return OK;
}

Status ListEmpty(SLinkList L)
{
    //操作结果：若L是空表，返回TRUE；否则返回FALSE
    return L[MAXSIZE-1].cur==0;
}

int ListLength(SLinkList L)
{
    //操作结果：返回L中数据元素个数
    int j = 0,i = L[MAXSIZE-1].cur;  //i指向第一个元素
    while(i)                         //没到静态链表尾
    {
        i = L[i].cur;                //指向下一个元素
        j++;
    }
    return j;
}

Status GetElem(SLinkList L,int i,ElemType *e)
{
    //操作结果：用e返回L中第i个元素的值
    int l,k = MAXSIZE-1;          //k指向表头序号
    if(i<1||i>ListLength(L)) return ERROR;
    for(l = 1; l<=i; l++)   //移动到第i个元素处
        k = L[k].cur;
    *e = L[k].data;
    return OK;
}

int LocateElem(SLinkList L,ElemType e)
{
    //操作结果：在静态单链线性表L中查找第1个值为e的元素。若找到，则返回它在L中的位序，否则返回0。
    int i = L[MAXSIZE-1].cur;  //i指示表中第一个结点
    while(i&&L[i].data!=e)     //在表中顺链查找
        i = L[i].cur;
    return i;
}

Status PriorElem(SLinkList L,ElemType cur_e,ElemType *pre_e)
{
    //初始条件：线性表L已存在
    //操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义
    int j,i = L[MAXSIZE-1].cur;   //i指示链表第一个结点的位置
    do
    {
        j = i;
        i = L[i].cur;             //向后移动结点
    }
    while(i&&L[i].data!=cur_e);
    if(i)                         //找到该元素
    {
        *pre_e = L[j].data;
        return OK;
    }
    return ERROR;
}

Status NextElem(SLinkList L,ElemType cur_e,ElemType *next_e)
{
    //初始条件：线性表L已存在
    //操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，否则操作失败，next_e无定义
    int j,i = LocateElem(L,cur_e);//在L中查找第一个值为cur_e的元素的位置
    if(i)                         //L中存在元素cur_e
    {
        j = L[i].cur;             //cur_e的后继的位置
        if(j)                     //cur_e有后继
        {
            *next_e = L[j].data;
            return OK;            //cur_e元素有后继
        }
    }
    return ERROR;                 //L不存在cur_e元素,cur_e元素无后继
}

Status ListTraverse(SLinkList L,void (*vi)(ElemType))
{
    //初始条件:线性表L已存在
    //操作结果:依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败
    int i = L[MAXSIZE-1].cur;   //指向第一个元素
    while(i)                    //没到静态链表尾
    {
        vi(L[i].data);          //调用vi()
        i = L[i].cur;           //指向下一个元素
    }
    printf("\n");
    return OK;
}

Status ListInsert(SLinkList L,int i,ElemType e)
{
    //操作结果：在L中第i个元素之前插入新的数据元素e
    int l,j,k = MAXSIZE-1;       //k指向表头
    if(i<1||i>ListLength(L)+1) return ERROR;
    j = Malloc(L);               //申请新单元
    if(j)                        //申请成功
    {
        L[j].data = e;           //赋值给新单元
        for(l = 1; l<i; l++)     //找到第i-1个元素的位置
            k = L[k].cur;
        L[j].cur = L[k].cur;     //改变指针，大家可以回忆一下指针链表的插入过程
        L[k].cur = j;
        return OK;
    }
    return ERROR;
}

Status ListDelete(SLinkList L,int i,ElemType *e)
{
    //操作结果：删除在L中第i个数据元素e，并返回其值
    int j,k = MAXSIZE-1;       //k指向表头
    if(i<1||i>ListLength(L)) return ERROR;
    for(j = 1; j<i; j++)       //找到第i-1个元素的位置
        k = L[k].cur;
    j = L[k].cur;              //改变指针，大家可以回忆一下指针链表的删除过程
    L[k].cur = L[j].cur;
    *e = L[j].data;
    Free(L,j);
    return OK;
}

void visit(ElemType c)
{
    printf("%d ",c);
}

int main()
{
    int j,k;
    Status i;
    ElemType e,e0;
    SLinkList L;
    InitList(L);
    for(j=1; j<=5; j++)
        i=ListInsert(L,1,j);
    printf("在L的表头依次插入1～5后：L=");
    ListTraverse(L,visit);
    i=ListEmpty(L);
    printf("L是否空:i=%d(1:是 0:否)表L的长度=%d\n",i,ListLength(L));
    i=ClearList(L);
    printf("清空L后：L=");
    ListTraverse(L,visit);
    i=ListEmpty(L);
    printf("L是否空:i=%d(1:是 0:否)表L的长度=%d\n",i,ListLength(L));
    for(j=1; j<=10; j++)
        ListInsert(L,j,j);
    printf("在L的表尾依次插入1～10后：L=");
    ListTraverse(L,visit);
    GetElem(L,5,&e);
    printf("第5个元素的值为：%d\n",e);
    for(j=0; j<=1; j++)
    {
        k=LocateElem(L,j);
        if(k)
            printf("值为%d的元素在静态链表中的位序为%d\n",j,k);
        else
            printf("没有值为%d的元素\n",j);
    }
    for(j=1; j<=2; j++)         //测试头两个数据
    {
        GetElem(L,j,&e0);       //把第j个数据赋给e0
        i=PriorElem(L,e0,&e);   //求e0的前驱
        if(!i)
            printf("元素%d无前驱\n",e0);
        else
            printf("元素%d的前驱为：%d\n",e0,e);
    }
    for(j=ListLength(L)-1; j<=ListLength(L); j++) //最后两个数据
    {
        GetElem(L,j,&e0);       //把第j个数据赋给e0
        i=NextElem(L,e0,&e);    //求e0的后继
        if(!i)
            printf("元素%d无后继\n",e0);
        else
            printf("元素%d的后继为：%d\n",e0,e);
    }
    k=ListLength(L);           //k为表长
    for(j=k+1; j>=k; j--)
    {
        i=ListDelete(L,j,&e);  //删除第j个数据
        if(i)
            printf("删除的元素为：%d\n",e);
        else
            printf("删除第%d个数据失败\n",j);
    }
    printf("依次输出L的元素：");
    ListTraverse(L,visit);      //依次对元素调用visit()，输出元素的值
    return 0;
}


总结：

静态链表的学习也就这样告一段落吧，不知道大家是否学会了呢？

学习的过程最重要的是自己动手，将所学的知识思考与总结，这样才能把别人的转化为自己的。

那么这次就到此为止，下次我们将会进入循环链表的学习。

月下键客
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【头歌】单链表的基本操作
qq_39977056的博客
01-23 1万+
由于单链表中每个结点的存储地址是存放在其前趋结点的指针域中的，而第一个结点无前趋，头指针L指向第一个结点，对于整个单链表的读取必须从头指针开始，同时，由于单链表中最后一个结点的指针域为“空”（NULL），没有直接后继元素，对于整个单链表的读取必须在尾结点结束。要在带头结点的单链表L中删除第i个结点，则同样要先找到第i-1个结点，使p指向第i-1个结点，使q指向第i个结点，然后令第i-1个结点的指针域指向第i+1个结点，而后删除q指向的第i个结点并释放结点空间。= NULL时，才能进行删除结点的操作。
数据结构学习之路-第二章：线性单链表
月下的寂寞肖邦
08-25 1030
【 声明：版权所有，转载请标明出处，请勿用于商业用途。  联系信箱：libin493073668@sina.com】 前言： 前面我们已经学习了顺序表的构建，我们知道顺序表就好像一个数组一样，在取出某个位置的时候，时间复杂度是O(1)，但是在插入与删除的时候，却每次都需要对其他位置的数进行移位，这样就显得效率比较低下了，那么我们怎么在插入与删除的过程中来优化这个时间复杂度呢？这
关于数据结构学习中typedef的一些奇怪用法
m0_74717371的博客
03-15 91
在学习数据结构中遇到的关于typedef的一些使用问题
第二章：3.线性表---静态链表的表示和实现
12-15 294
前言： 　　由于一些高级程序设计语言中，并没有 “指针” 类型，因此上一节中用指针来描述的单链表不能被实现，这时候我们就会使用另一种形式链表：静态链表。 目录： 1.线性表的链式表示和实现 　　1.1线性链表 　　　　单链表（指针型线性链表） 　　　　静态链表 　　1.2循环链表 　　1.3双向链表 正文： 　　线性表的静态单链表存储结构： 　　　　#d...
有序单链表的插入删除操作
qq_45917176的博客
06-30 3098
数据结构--有序单链表的插入删除操作
数据结构（二）—— 线性表
qq_45812711的博客
05-05 574
一、概述 1.线性表相关概念 （1）第一个元素成为首元，最后一个元素成为尾元。 （2）有序线性表按元素的值递增排列；无序线性表元素的值和位置之间没有直接关系。若不特别说明，默认是无序线性表。 二、顺序表 1.相关概念： （1）线性表的储存方式有两种，顺序储存方式和链表储存方式。用顺序储存方式实现的线性表成为顺序表，用一维数组作为其储存结构。 （2）特点： 在顺序表中，各个元素的逻辑顺序...
数据结构学习笔记2：单链表
m0_52799531的博客
04-29 887
don't talk too much,here is the teacher's code: 1. 单链表概念&设计 单链表是一种链式存取的数据结构，，链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。 对于链表的每一个结点，我们使用结构体（struct）进行设计，其主要内...
数据结构第二章-2.3
11-23
本章节“数据结构第二章-2.3”主要聚焦于链式数据结构，包括静态链表、顺序表与链表的比较、单链表的建立、循环链表以及双链表。 首先，我们来看静态链表。静态链表是一种在内存中预先分配好连续空间的数据结构，与...
数据结构第二章参考答案.doc
12-17
数据结构是计算机科学中最重要的基础知识之一，本章参考答案涵盖了数据结构第二章的主要知识点，包括单链表、顺序表、链表、静态链表、双链表、循环链表、顺序存储结构、链式存储结构、动态内存管理、STL 中的容器等...
4 数据结构第二章知识点-3.doc
最新发布
01-14
数据结构第二章知识点 本章节主要介绍了线形表的存储结构，包括循环单链表、双链表和静态链表等。下面是本章节的知识点总结： 知识点 1：循环单链表从任意一个结点出发都能遍历整个单链表。 在循环单链表中，任何...
数据结构李春葆第五版1--3章ppt
08-11
第二章通常会深入到线性结构，特别是数组和链表。数组是一种静态的数据结构，其中元素在内存中是连续存储的，而链表则是动态的，元素通过指针连接。链表分为单链表、双链表和循环链表，每种都有其特定的插入和删除...
第二章：线性表-21
08-03
总之，理解和掌握线性表的各种实现方式对于学习数据结构和算法至关重要，因为线性表是许多其他复杂数据结构的基础，如栈、队列、树等。了解其内部工作原理和优化策略有助于提升程序的效率和可维护性。
静态链表的实现
rujin_shi的博客
03-07 3519
静态链表 用数组来代替指针，来描述单链表 将数组元素分成两个数据域，data和cur。data用来存放数据元素，cur存放该元素的后继在数组中的下标(游标)。&lt;游标实现法&gt; 1.基本结构 /*线性表的静态链表存储结构*/ #define MAXSIZE 1000 typedef struct { ElemType data; int cur; /*游标(Cursor)，...
2-2-1链表的基本操作
i_am_kiki的博客
08-19 313
2-2-1链表的基本操作(头结点与不带头结点的链表) 下面不带头结点的链表操作,与带头结点的链表操作,都用到同一个数据存储结构LinkListType.h //LinkListType.h线性表的单链表存储结构 #pragma once #ifndef __LINKLISTTYPE_H__ #define __LINKLISTTYPE_H__ typedef int ElemType; s...
数据结构第三章 线性表
郑哥哥の博客
07-25 831
线性表：零个或多个数据元素的有限序列 注意： （1）线性表是一个序列，元素之间是有顺序的，若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他每个元素都有且仅有一个前驱和后继。 （2）线性表是有限的，即元素个数是有限的。 （3）线性表元素的个数n(n>=0)定义为线性表的长度，当n=0时，称为空表。 在较复杂的线性表中，一个数据元素可以由若干个数据项组成 线性表的抽象数据类型 ADT 线性表(List) Data Operation InitList(*L); //初始化操作，建立一
数据结构c语言版静态链表,静态链表----数据结构（C语言版） 算法2.17 心得
weixin_35662085的博客
05-21 383
今天学习了数据结构中的静态链表，刚开始有些语句不能理解，研究了大半天终于想通了。记录于此留待以后查看，同时，对于同样对静态链表有些许不理解的人一点启发首先，了解一下静态链表。静态链表中跟单链表类似，包含有很多结点，第i个结点中有包括数据space[i].data，和游标cur，游标space[i].cur的值为下一个结点的数组下标。2：数组下标4：游标域(space[i].cur的值为下一个结点的...
静态（单）链表分析——游标与一维数组
m0_60412535的博客
05-28 932
前言 （本文参考严蔚敏《数据结构》C语言版，针对静态单链表提供了更为详细的分析，并加入了一些自己的风格，供初学者参考讨论） 在了解静态单链表之前，我们先简要回顾一下顺序表和动态单链表： 1）顺序表： 数组实现，用一组地址连续的存储单元依次存储线性表的数据元素。利用 realloc 和 LISTINCREMENT（块）实现变长数组（resizable array） 特点：逻辑上相邻的两个元素在物理位置上也相邻。 优点：允许随机访问（通过下标），“求表长”和“取第 i 个元素”时间复杂度O（1）。
数据结构学习之路-第三章：栈的应用
月下的寂寞肖邦
09-08 3832
【 声明：版权所有，转载请标明出处，请勿用于商业用途。  联系信箱：libin493073668@sina.com】 前言： 前面已经介绍过栈的相关操作的具体实现，那么现在就按照书上的几个例子来具体讲一下栈的具体用处。 没有看之前我写的栈的实现的同学可以去看：传送门在这里哟 因为这里要用到我前面那篇博文中的函数，我都统一归集在一个头文件中，也就是下面的"my_stack
数据结构c语言2022优秀文档.ppt
11-13
通过学习数据结构中的查找操作，我们可以得出一些结论：首先，在数组中按编号查找元素的时间复杂度是O(1)，即常数时间内能够完成查找操作。其次，我们可以通过特殊的方法将给定的查找表组织到数组中，如哈希表的方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值