数据结构（三）-线性表-链式存储结构、静态链表（Java、C语言）

最新推荐文章于 2025-01-23 14:56:06 发布
原创 最新推荐文章于 2025-01-23 14:56:06 发布 · 1.1k 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
数据结构

当前文章被收录于：

数据结构
12 篇文章 0 人学习
订阅专栏 查看详情
本文探讨了顺序存储结构的不足，特别是插入和删除操作的效率问题，然后介绍了链式存储结构，包括链表的工作原理、C语言和Java的代码示例。讨论了静态链表、循环链表和双向链表，并重点强调了链式存储在时间复杂度上的优势。

本篇文章紧接上篇文章，上文了解了线性表的顺序存储结构，本篇文章我们来了解线性表的链式存储结构，并对比两种存储结构的优缺点。

文章目录

一、顺序存储结构的不足

顺序存储结构虽然有它的优点，但是，顺序存储结构也有一个很大的缺陷，它的插入和删除需要挪动大量的元素，造成算法效率的问题，现在存储的数据，进行的操作还比较少，所以感受不到，但是当操作数量达到一定程度的时候，用顺序存储结构写的算法的不足就体现出来了。

二、链式存储结构

上面顺序存储结构所说的不足，由此，我们需要链式存储结构来解决这个问题
我们通过一个例子来了解链式存储结构与顺序存储结构的区别

例1
假设现在有两家动物园，两家动物园为了游客能够观看到所有动物，以及方便游客进行寻找，A动物园将每种动物观赏地放在一条线路上，每一种动物前后都有上一种动物和下一种动物；B动物园将每种动物放在了最适合的位置，散落在动物园各处，为了方便游客，在每种动物的观赏地会放上一块牌子，推荐游客去往下一个地方，以便游客看完所有动物。现在，动物园要新加一种动物，A动物园想把它放到中间，但是没有位置了，必须将后半部分的动物向后挪一个位置才行；而B动物园只需要更换一块牌子，将上一个动物的指示牌指到新加动物这里即可，新加动物的指示牌再指向下一个动物。工作量是不是会小很多。

由此，我们可出，A动物园便是一种顺序存储结构，它的存储单元是连续的，插入和删除操作都需要挪动大量元素，而链式存储结构则不需要，它的存储空间是任意的，只需要在每个元素中再加入存储下一个元素的指针便可，这样一来，后面的存储位置是不需要变动的。这样，大大减少了算法执行时间，但是也增加了数据存储的大小，因此，这可以说是牺牲了空间换来了时间。

三、链式存储结构代码（C语言）

C语言提供了一个良好的工具，便是指针，我们可以通过指针来存储下一个数据存储的位置。每一个数据+指针叫做一个结点，存储的数据叫做数据域，存储指针的地方叫做指针域。
在这里插入图片描述
这里需要区分头指针与头结点的区别：
头指针：

  • 头指针是指链表指向的第一个结点的指针，若链表有头结点，则是指向头结点的指针；
  • 头指针具有标志作用，所以常用头指针冠以链表的名字
  • 无论链表是否为空，头指针均不为空，头指针是链表的必要元素

头结点：

  • 头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域一般无意义（也可以存放链表长度）
  • 有了头结点，对在第一个元素结点前插入结点和删除第一结点，其操作与其他结点就统一了
  • 头结点不一定是链表必须的元素

总得来说，头结点是为了操作方便设立的，不要也可以。

链表相比于顺序存储结构也有其缺点，例如查询操作，它必须从第一个结点开始，指向后一个元素，直到查到为止，时间复杂度为n，相比于顺序存储结构的1，确实麻烦了一些，但是链表的插入与删除将会体现出它优于顺序存储结构的地方。在这里插入图片描述
上面那张图应该清晰地说明了插入操作，就是改变指针指向的位置。删除也是同样的操作，就是将要删除的结点的上一个结点的指针域指向删除结点的下一个结点即可。
下面是代码（这个代码是大话数据结构里的例程代码，我觉得写得已经非常清楚了）

看这段代码建议先复习一下结构体相关知识和结构体指针相关知识，因为我看这段代码看了好久┭┮﹏┭┮

#include "stdio.h"    
#include "string.h"
#include "ctype.h"      
#include "stdlib.h"   

#include "math.h"  
#include "time.h"

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

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */


Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */

/* 初始化链式线性表 */
Status InitList(LinkList *L) 
{ 
    *L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
    if(!(*L)) /* 存储分配失败 */
            return ERROR;
    (*L)->next=NULL; /* 指针域为空 */

    return OK;
}

/* 初始条件：链式线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(LinkList L)
{ 
    if(L->next)
            return FALSE;
    else
            return TRUE;
}

/* 初始条件：链式线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{ 
	LinkList p,q;
	p=(*L)->next;           /*  p指向第一个结点 */
	while(p)                /*  没到表尾 */
	{
		q=p->next;
		free(p);
		p=q;
	}
	(*L)->next=NULL;        /* 头结点指针域为空 */
	return OK;
}

/* 初始条件：链式线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next; /* p指向第一个结点 */
    while(p)                        
    {
        i++;
        p=p->next;
    }
    return i;
}

/* 初始条件：链式线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
	int j;
	LinkList p;		/* 声明一结点p */
	p = L->next;		/* 让p指向链表L的第一个结点 */
	j = 1;		/*  j为计数器 */
	while (p && j<i)  /* p不为空或者计数器j还没有等于i时，循环继续 */
	{   
		p = p->next;  /* 让p指向下一个结点 */
		++j;
	}
	if ( !p || j>i ) 
		return ERROR;  /*  第i个元素不存在 */
	*e = p->data;   /*  取第i个元素的数据 */
	return OK;
}

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

    return 0;
}


/* 初始条件：链式线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{ 
	int j;
	LinkList p,s;
	p = *L;   
	j = 1;
	while (p && j < i)     /* 寻找第i个结点 */
	{
		p = p->next;
		++j;
	} 
	if (!p || j > i) 
		return ERROR;   /* 第i个元素不存在 */
	s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */
	s->data = e;  
	s->next = p->next;      /* 将p的后继结点赋值给s的后继  */
	p->next = s;          /* 将s赋值给p的后继 */
	return OK;
}

/* 初始条件：链式线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e) 
{ 
	int j;
	LinkList p,q;
	p = *L;
	j = 1;
	while (p->next && j < i)	/* 遍历寻找第i个元素 */
	{
        p = p->next;
        ++j;
	}
	if (!(p->next) || j > i) 
	    return ERROR;           /* 第i个元素不存在 */
	q = p->next;
	p->next = q->next;			/* 将q的后继赋值给p的后继 */
	*e = q->data;               /* 将q结点中的数据给e */
	free(q);                    /* 让系统回收此结点，释放内存 */
	return OK;
}

/* 初始条件：链式线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

/*  随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
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;             /*  随机生成100以内的数字 */
		p->next = (*L)->next;    
		(*L)->next = p;						/*  插入到表头 */
	}
}

/*  随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n) 
{
	LinkList p,r;
	int i;
	srand(time(0));                      /* 初始化随机数种子 */
	*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
	r=*L;                                /* r为指向尾部的结点 */
	for (i=0; i<n; i++) 
	{
		p = (Node *)malloc(sizeof(Node)); /*  生成新结点 */
		p->data = rand()%100+1;           /*  随机生成100以内的数字 */
		r->next=p;                        /* 将表尾终端结点的指针指向新结点 */
		r = p;                            /* 将当前的新结点定义为表尾终端结点 */
	}
	r->next = NULL;                       /* 表示当前链表结束 */
}

int main()
{        
    LinkList L;
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化L后：ListLength(L)=%d\n",ListLength(L));
    for(j=1;j<=5;j++)
            i=ListInsert(&L,1,j);
    printf("在L的表头依次插入1～5后：L.data=");
    ListTraverse(L); 

    printf("ListLength(L)=%d \n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    i=ClearList(&L);
    printf("清空L后：ListLength(L)=%d\n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    for(j=1;j<=10;j++)
            ListInsert(&L,j,j);
    printf("在L的表尾依次插入1～10后：L.data=");
    ListTraverse(L); 

    printf("ListLength(L)=%d \n",ListLength(L));

    ListInsert(&L,1,0);
    printf("在L的表头插入0后：L.data=");
    ListTraverse(L); 
    printf("ListLength(L)=%d \n",ListLength(L));

    GetElem(L,5,&e);
    printf("第5个元素的值为：%d\n",e);
    for(j=3;j<=4;j++)
    {
            k=LocateElem(L,j);
            if(k)
                    printf("第%d个元素的值为%d\n",k,j);
            else
                    printf("没有值为%d的元素\n",j);
    }
    

    k=ListLength(L); /* k为表长 */
    for(j=k+1;j>=k;j--)
    {
            i=ListDelete(&L,j,&e); /* 删除第j个数据 */
            if(i==ERROR)
                    printf("删除第%d个数据失败\n",j);
            else
                    printf("删除第%d个的元素值为：%d\n",j,e);
    }
    printf("依次输出L的元素：");
    ListTraverse(L); 

    j=5;
    ListDelete(&L,j,&e); /* 删除第5个数据 */
    printf("删除第%d个的元素值为：%d\n",j,e);

    printf("依次输出L的元素：");
    ListTraverse(L); 

    i=ClearList(&L);
    printf("\n清空L后：ListLength(L)=%d\n",ListLength(L));
    CreateListHead(&L,20);
    printf("整体创建L的元素(头插法)：");
    ListTraverse(L); 
    
    i=ClearList(&L);
    printf("\n删除L后：ListLength(L)=%d\n",ListLength(L));
    CreateListTail(&L,20);
    printf("整体创建L的元素(尾插法)：");
    ListTraverse(L); 


    return 0;
}

四、线性表的链式存储结构（Java）

由于Java并没有指针变量这个概念，也没有结构体，因此，结构体我们将使用类来代替，而指针地址其实就是对象名，我们可以定义一个结点类来存放下一个结点。

那么思路就是：我们定义一个结点类Node用来作为结点，Node类中有数据域和指针域，指针域由Node next来实现，这个指针其实是一个类。定义链表类，这个类中包含头指针和尾指针，还有对链表进行的操作，并且对链表进行泛型化，可以存储任何对象。

下面的代码是我自己写的，可能存在一些不足，封装得也不是很好。至于删除和插入的操作，其实和C语言是一样的，可以看上面。

package date;

public class LinkedList<E>{
	private Node head;//链表的头结点
	private Node rear;//链表的尾指针
	private int size=0;
	private class Node{//结点类
		E data;//数据域
		Node next;//指针域
		public Node(){
			this.data=null;
			this.next=null;
		}
		public Node(E e){
			this.data=e;
			this.next=null;
		}
		public Node(E e,Node next){
			this.data=e;
			this.next=next;
		}
	}
	public LinkedList() {//尾指针为空，头指针指向尾指针，达到创建链表的作用
		this.head=new Node();
		this.rear=null;
	}
    public void add(int index, E e) {
        if(index<0 || index>size){
            throw new IllegalArgumentException("角标越界");
        }
        Node n = new Node(e);
        if(size==0){
            head.next = n;
            rear = n;
        }else if(index ==0){        //头插法
            n.next = head.next;
            head.next = n;
        }else if(index == size){   //尾插法
            rear.next = n;
            rear = n;
        }else{      //中间插
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            n.next = p.next;
            p.next = n;
        }
        this.size++;
    }
    public E remove(int index) {
        if(size==0){
            throw new IllegalArgumentException("空表");
        }
        if(index<0 || index>=size){
            throw new IllegalArgumentException("角标越界");
        }
        E res = null;
        if(size == 1){//只有一个数据的时候
            res = head.next.data;
            head.next = null;
            rear = head;
        }else if(index == 0){
            Node del = head.next;
            res = del.data;
            head.next = del.next;
            del.next = null;
            del = null;
        }else if(index == size-1){
            Node p = head;
            while(true){
                if(p.next != rear){
                    p = p.next;
                }else{
                    break;
                }
            }
            res = p.next.data;
            p.next = null;
            rear = p;
        }else{
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            Node del = p.next;
            res = del.data;
            p.next = del.next;
            del.next = null;
            del = null;     
        }
        size--;
        return res;
    }
    public E get(int index) {
        if(size==0){
            throw new IllegalArgumentException("空表");
        }
        if(index<0 || index>size){
            throw new IllegalArgumentException("角标越界");
        }
        if(index == 0){
            return head.next.data;
        }else if(index == size-1){
            return rear.data;
        }else{
            Node p = head;
            for (int i = 0; i <= index; i++) {
                p = p.next;
            }
            return p.data;
        }
    }
    public static void main(String[] args) {
    	LinkedList s=new LinkedList();
    	for(int i=0;i<5;i++)
    	{
    		s.add(i, i);
    	}
    	System.out.println("链表长度："+s.size);
    	System.out.println("第2个数据："+s.get(2));
    	System.out.println("删除第2个数据");
    	s.remove(2);
    	for(int i=0;i<s.size;i++)
    	{
    		System.out.println("输出"+s.get(i));
    	}
    }

}

五、静态链表

  1. 为什么需要静态链表：C语言通过指针可以很好地操作内存中的数据，Java通过对象引用机制，也实现了指针的功能，但是早期的语言Basic等语言，并不能实现这种功能，那么怎么来实现链表呢？那就是使用数组来描述链表。
  2. 如何实现静态链表：我们知道，每一个结点需要一个指针域和数据域，在C语言中，我们同样采用结构体来实现，但是此时的指针域，我们不用结构体指针来实现，定义一个int型变量，作为游标。我们用数组作为一个链表来存储这些结构体，而游标则是指向下一个结构体存储在数组中存放的位置的下标。这样我们就实现了不使用指针变量也能实现链表。

静态链表虽然实现了链表，解决了顺序存储结构的元素移动问题，它只用修改游标即可，但是它由于是使用了数组来进行描述，丢失了链式存储结构的随机存取的特点。因此，静态链表的使用在C语言与Java中使用得并不多，也不推荐使用。

所以这里就不放代码了，大家可以试试，用数组来描述的话会好理解一点。

六、循环链表与双向链表

在这里插入图片描述

这两个链表其实没有什么特别之处，循环链表就是将第一结点与尾结点连起来，双向链表就是结点存储的指针域有两个，我们暂且称其为父节点与子结点，父结点就是指向上一个结点的指针，子结点就是指向下一个结点的指针，这样当我们进行搜索的时候，就可以进行双向搜索。

在这里插入图片描述
弄懂了单链表，那么无论是循环链表，还是双向链表，还是循环双向链表，其实都是一样的，我们需要弄懂的是链表的基本概念与存储方式。

标签
#数据结构 #c语言 #链表 #java
比较顺序存储和链接存储两种存储结构的有缺点
12-07
比较顺序存储和链接存储两种存储结构的有缺点。 1. 分别用顺序存储和链接存储实现线性表的基本操作； 2. 比较两者的优缺点，并说明两者的适用场合。
顺序链表，单链表，静态链表求解的约瑟夫问题josephus的C语言代码，可以直接运行
03-16
用顺序链表，单链表，静态链表三种结构求解的约瑟夫josephus问题，完整的代码，可以直接编译，运行的，
6.线性表：顺序表和链表的优缺点
speedwalkman的专栏
07-03 2694
本章节主要介绍顺序表和链表的定义、特点、优点、缺点和适应环境
线性表链式存储结构C语言实现
10-04
线性表 链式存储结构 C语言实现 VC6.0
数据结构——顺序存储结构&链式存储结构的区别和用法
热门推荐
刘鑫磊
02-10 6万+
目录： 一：线性表的顺序存储结构 1.定义 2.顺序存储示意图如下所示： 3.编号地址 4.存储位置公式 5.存取操作时间性能 6.随机存储结构 7.时间复杂度 （1）对于存取操作 （2）对于插入和删除操作 8. 使用场景 二：线性表的链式存储结构 1.什么是链表 2.结点 （1）数据域 （2）指针域 3.头指针&头结点 （1）头指针 （2）...
链式存储结构
qq_58138249的博客
10-15 1122
循环链表是一种特殊的链表数据结构，与单向链表或双向链表相比，循环链表的最后一个节点的下一个节点指向第一个节点，从而形成一个环形结构。因此，循环链表可以在最后一个节点后继续添加节点，并且可以像单向链表或双向链表一样遍历、查找和删除节点。循环链表通常有一个头指针和一个尾指针，它们指向第一个节点和最后一个节点，以便在添加或删除节点时快速定位。循环链表可以用于解决某些问题，例如模拟一个环形队列，或者用于实现循环播放的音乐列表等。
【数据结构】线性表——顺序表 链式表 单链表 双链表 循环链表 静态链表
m0_61628700的博客
06-27 761
线性表——顺序表 链式表 单链表 双链表 循环链表 静态链表
链式存储表
Z5433523的博客
08-19 206
申请一个结构的头 存储数据的首地址，以及这个结构的其他参数。链式 物理上不连续 增加 元素逻辑的关系。在第二个位置上，进行插入操作时，如果索引指针指向第二个节点，无法进行后续操作。链式存储维护 表内容的首结点，首结点逐个寻找其他节点。一旦把节点的next赋新值，之前的下一个元素的关系，就断开。单链表中，一旦索引指针往前走一步，之前的元素就再也找不到。删除A元素，站在A元素的前一个元素上，才能删除A元素。链式存储的特点和核心操作逻辑。
C语言数据结构--线性表
别下完这场雪
05-30 3934
严蔚敏老师的C语言数据结构一书中，使用的都是伪代码，实际运行总是会出现问题，这里将线性表的伪代码补全，还有完整的程序代码
数据结构（二）——线性表
L的博客
09-07 2535
一：线性表的概述 线性表是最简单最基本的一种数据结构，线性表中的数据元素都存在一对一的关系，属于线性结构，是有顺序有先后关系的，除了第一个元素外，其他数据元素前只有一个数据元素（前驱），除了最后一个元素外，其他数据元素后只有一个数据元素（后驱） 二：线性表的顺序存储结构 用一段地址连续的存储单元依次存储线性表中的数据元素线性表的顺序存储结构在读、存数据时，时间复杂度都是O(1)，我们把读、存...
C语言数据结构（大话数据结构——笔记1）数据结构绪论、算法、线性表
Dontla的博客
06-25 817
【C语言描述】《数据结构和算法》 说是这个教程是按照《大话数据结构》这本书来编写的：数据结构与算法经典书籍——大话数据结构（带配套源码） ↑废话太TM多了，换一个！ 【搞定数据结构和算法】数据结构和算法考研教程数据结构考研严蔚敏 这个好像可以，看这个。。。 但是没更完啊！换一个！ 我裂开了，还是回去看那个小甲鱼的罗里吧嗦的教程吧！ 越听越晕，wo TM还是不看视频了，直接看书吧，《大话数据结构》！ 文章目录 逻辑结构与物理结构（存储结构） 顺序存储结构与链式存储结构 抽象数据类型 （39） 原子类型数据与结
数据结构与算法（七）静态链表
less_duuuzx的博客
10-05 1849
静态链表是一种比较古老的用法了，一般用在没有指针操作的传统语言上，对于我们日常工作的使用，是大概率用不上这个操作方式的。考虑到考试的需要以及对静态链表思想的把握，笔者还是将这一部分的内容纳入数据结构与算法专栏的学习内容当中，如果没有考试需求的读者，可以根据自身情况忽略该部分介绍。另外后面加入了腾讯的一道面试题，供大家一起学习！数据结构与算法（c语言实例）_Felix Du的博客-CSDN博客欢迎各位批判指正！
线性表文档之静态链表
二木成林
04-05 1342
线性表文档之静态链表
java静态链表_Java数据结构——静态链表实现
weixin_36434922的博客
02-13 466
Java数据结构——静态链表实现一、定义用数组描述的链表，即称为静态链表。在C语言中，静态链表的表现形式即为结构体数组，结构体变量包括数据域data和游标CUR。(这里的定义来自于百度百科)二、优点(1)这种存储结构，仍需要预先分配一个较大的空间，但在作为线性表的插入和删除操作时不需移动元素，仅需修改指针，故仍具有链式存储结构的主要优点。(2)假如有如上的静态链表S中存储这线性表(a，b，c，d，...
大话数据结构系列之线性表（三）
威少（微笑）
01-16 621
文章目录线性表定义基础结构划分顺序存储结构优点缺点C 语言实现Java 语言实现 线性表 定义 零个或多个元素的有限序列 数学逻辑表达 若将线性表标记为（ a[1], a[2], a[3]~~~ a[i-1], a[i], a[i+1]~~~ a[n] ），则表中 a[i-1] 领先于 a[i]，a[i] 领先于 a[i+1]，称 a[i-1] 是 a[i] 的直接前驱元素，a[i+1] 是 a...
JAVA与数据结构-线性表
最新发布
startshining_ys的博客
01-23 1247
辅助总结理解线性表
静态链表的通俗讲解与基本操作（C语言）
javatrip01的博客
09-20 789
静态链表的通俗讲解与基本操作（C语言）
重学数据结构之第三章-线性表
James-Tom的博客
10-02 800
线性表：零个或多个数据元素的有限序列。 几个关键点：首先它是一个序列，元素之间是有顺序的，若存在多个元素，则第一个元素无前驱，最后一个元素无后继，其他每个元素有且只有一个前驱和后继。 前驱和后继后续文章中也会提到，就是指的前一个数据元素和后一个数据元素，只是简化了叫法。
显式空闲链表和隐式空闲链表_数据结构静态链表
weixin_39927623的博客
11-24 2085
一、回顾简单回顾一下前面学习到的知识。我们已经知道数据结构中的线性表包含顺序存储结构和链式存储结构。其中链式存储结构中包含了单链表。在顺序存储结构的实现中，主要是申请了一块连续的内存来存储数据元素。而单链表的存储结构中是不需要提前申请内存的。它可随时随地申请一块连续或不连续的物理内存来存储数据元素。单链表可以通过头插法和尾插法来实现数据元素的顺序储存格式或逆序的存储格式。和顺序存储结构相...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值