顺序表和链表超详细大总结

最新推荐文章于 2022-08-10 20:51:55 发布
最新推荐文章于 2022-08-10 20:51:55 发布
阅读量1.6k 收藏 55
点赞数 66
分类专栏： 数据结构 文章标签： 数据结构 c语言 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66314292/article/details/124745230
版权

本文章是对顺序表和链表的详细总结，包括各结构优缺点，顺序表的接口实现，单向不带头不循环链表接口实现，双向带头循环链表的接口实现。

另外还有两篇单链表的题目详解，可以加深理解：
LeetCode刷题——单链表（详细图解）
剑指Offer——环形链表问题（面试延伸证明）
记得三连哦💞💞💞

顺序表和链表

顺序表

一、🌞顺序表的基本介绍

1.1💡线性表和顺序表

1️⃣线性表是N个具有相同特性的数据元素的有限序列。线性表不等同于顺序表，常见的线性表有：顺序表，链表，字符串，队列，栈等。都是属于线性结构。
2️⃣顺序表本质上是数组，并且存储数据是从左向右连续的。

所以顺序表是线性表的一部分。

1.2💡物理结构和逻辑结构

逻辑结构可以理解为我们想象的结构

而物理结构则是真实的结构。

用顺序表和链表来举例子：
逻辑结构：
在这里插入图片描述
单链表的物理结构和逻辑结构是相同的，但是链表的物理结构可能是杂乱的
例如：
在这里插入图片描述

1.3💡静态顺序表

#define N 100
typedef int SeqDateType;//方便修改类型
typedef struct SeqList
{
	SeqDateType a[N]; 
	int size; //有效数据的个数
}SeqList;

我们可以看到他的容量是固定的，无法动态增长

所以我们实际中用的是动态顺序表。

1.4💡动态顺序表

typedef int SeqDateType;//方便修改类型
typedef struct SeqList
{
	SeqDateType* a;
	int size;    //有效数据的数量
	int capacity;//容量
}SeqList, SEQ;

二、🌞顺序表的接口实现

首先创造个结构体变量：

SeqList s;

2.1💡顺序表的初始化(传址和断言)

void SeqListInit(SeqList* pq)
{
	assert(pq);//防止空指针
	pq->a = NULL;
	pq->capacity = 0;
	pq->size = 0;
}

这里一定要注意传的是地址
如果传的是s，那么初始化的是拷贝的结构体变量。并不会改变s本身。
那么接下来所有接口都要用传址
断言的好处：防止传进来的指针是空指针，直接结束程序，防止崩溃。
下面是不加断言和加上断言的对比：

void SeqListInit(SeqList* pq)
{
	//assert(pq);//防止空指针
	pq->a = NULL;
	pq->capacity = 0;
	pq->size = 0;
}


int main()
{
	SeqList s;
	SeqListInit(NULL);
	return 0;
}

在这里插入图片描述
我们可以看到程序已经崩溃了，而加上断言后：
在这里插入图片描述
会直接结果程序并且把错误的地方返回给我们。

2.2💡顺序表的尾插

用张图片感受下插入的方式：
在这里插入图片描述
从图片我们很容易能发现问题：如果顺序表最大容量和其有效元素个数相等的时候，我们需要扩容操作
在实际中为了不造成空间浪费，我们一般一次扩容成原来2倍
而两倍又出现了问题：如果顺序表一个元素都没有，容量也为0呢？

2.3💡顺序表的扩容

当顺序表的容量为0就申请空间，如果不为0就扩容至两倍

void SeqCheckCapacity(SeqList* pq)
{
	assert(pq);
	//满了就扩容
	if (pq->capacity == pq->size)
	{
		int newcapacity = pq->capacity == 0 ? 4 : 2 * pq->capacity;
		SeqDateType** NewA = realloc(pq->a, sizeof(SeqList) * newcapacity);
		//防止realloc后改变了pq原来指向的地址
		if (NewA == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			pq->a = NewA;
			pq->capacity = newcapacity;
		}
	}
}

可以发现我们没有直接在pq->a上扩容，而是先创建了NewA来指向开辟的空间
这就涉及到realloc的性质了：
在这里插入图片描述

有了扩容判断就可以解决上面的问题，接下来是尾插：

void SeqListPushBack(SeqList* pq, SeqDateType x)
{
	assert(pq);
	SeqCheckCapacity(pq);//扩容判断
	pq->a[pq->size] = x;
	pq->size++;
}

2.4💡顺序表的头插

头插我们可以把所有元素后移一位，再把要插入的元素插到第一个位置：
在这里插入图片描述

void SeqListPushFront(SeqList* pq, SeqDateType x)
{
	assert(pq);
	SeqCheckCapacity(pq);
	//从最后一个开始依次右移
	int cur = pq->size - 1;
	while (cur >= 0)
	{
		pq->a[cur + 1] = pq->a[cur];
		cur--;
	}
	pq->a[0] = x;
	pq->size++;
}

2.5💡顺序表的尾删

void SeqListPopBack(SeqList* pq)
{
	assert(pq);
	assert(pq->size > 0);//保证有数据删除
	pq->size--;
}

这里直接把size减一就可以了，因为size标识的就是有效元素的个数，后边的是什么我们不关心。
这里capacity不用也改变，满了就扩容，删数据空间不变。

2.6💡顺序表的头删

头删比较简单，不需要考虑容量满了的问题，直接让后一个覆盖前一个就可以了
在这里插入图片描述

void SeqListPopFront(SeqList* pq)
{
	assert(pq);
	//提醒没有元素可以删除了
	assert(pq->size > 0);
	int cur = 0;
	while (cur < pq->size - 1)
	{
		pq->a[cur] = pq->a[cur + 1];
		cur++;
	}
	pq->size--;
}

2.7💡顺序表的查找

查找直接遍历顺序表，找到了返回下标，有多个就返回第一个x的下标，没找到返回-1

int SeqListSearch(SeqList* pq, SeqDateType x)
{
	assert(pq);
	int cur = 0;
	while (cur < pq->size)
	{
		if (pq->a[cur] == x)
		{
			return cur;
		}
		cur++;
	}
	return -1;
}

2.8💡顺序表的指定位置插入

在这里插入图片描述

要求在任意位置插入，先判断容器是否满了， 再从pos的位置把元素向后挪动

void SeqListInsert(SeqList* pq, int pos, SeqDateType x)
{
	assert(pq);
	SeqCheckCapacity(pq);
	int end = pq->size - 1;
	while (end >= pos)
	{
		pq->a[end + 1] = pq->a[end];
		end--;
	}
	pq->size++;
	pq->a[pos] = x;
}

此时我们可以发现插入在任意位置的代码可以代替头插和尾插

2.8.1📍替代头插
void SeqListPushFront(SeqList* pq, SeqDateType x)
{
	assert(pq);
	int pos = 0;
	SeqListInsert(pq, pos, x);
}
2.8.2📍代替尾插
void SeqListPushBack(SeqList* pq, SeqDateType x)
{
	assert(pq);
	int pos = pq->size;
	SeqListInsert(pq, pos, x);
}

2.9💡顺序表的指定位置删除

把pos位置的删除后，把后面的元素依次往前移。

void SeqListPop(SeqList* pq, int pos)
{
	assert(pq);
	//保证有元素可删除
	assert(pq->size > 0);
	int cur = pos;
	while (cur < pq->size - 1)
	{
		pq->a[cur] = pq->a[cur + 1];
		cur++;
	}
	pq->size--;
}

此时我们可以发现删除在任意位置的代码可以代替头删和尾删

2.9.1📍替代头删
void SeqListPopFront(SeqList* pq)
{
	assert(pq);
	int pos = 0;
	SeqListPop(pq, pos);
2.9.2📍代替尾删
void SeqListPopBack(SeqList* pq)
{
	assert(pq);
	int pos = pq->size - 1;
	SeqListPop(pq, pos);

2.10💡顺序表的销毁

要删除开辟在堆上的空间，就用free释放，再把size和capacity重置为0

void SeqListDestory(SeqList* pq)
{
	assert(pq);
	free(pq->a);
	pq->a = NULL;
	pq->capacity = pq->size = 0;
}

2.11💡顺序表的打印

void SeqListPrint(SeqList* pq)
{
	for (int i = 0; i < pq->size; i++)
	{
		printf("%d ", pq->a[i]);
	}
	printf("\n");
}

传址的原因：
1️⃣如果传参，会在拷贝时申请一块新的一份空间，传址的时候只有四个字节的内存，节省了空间
2️⃣保持接口的统一性（全部是传址）

三、🌞顺序表的缺点及思考

1️⃣从中间或头部插入时间复杂度为O(N)（要挪动数据）。
2️⃣增容需要申请空间，拷贝数据，有时还要释放就空间，会产生不少的消耗，增容是有代价的。
3️⃣增容一般都是两倍增长，这样势必会有空间浪费。

那么如何解决这些问题呢？就会用到下面讲的链表了

链表

一、🌞链表的基本介绍及优缺点

链表的大致结构如图
在这里插入图片描述
优点：1️⃣如果要插入直接申请一份空间，连在上面就可以，这样时间复杂度就为O（1）
2️⃣不会造成空间浪费
在这里插入图片描述

但也会造成1️⃣频繁开辟空间2️⃣不能随机访问，所以不能完全取代顺序表，两者是各有优缺点，就像货车和轿车一样，都无法取代对方。

二、🌞八大链表结构

实际中链表的结构非常多样，以下的情况组合起来就有八种链表结构
1、单向和双向
2、带头和不带头
3、循环和非循环
用图的方式能最直观的感受

①单向带头循环链表

在这里插入图片描述
这里要注意PHead指向的结点是哨兵位，不存储任何数据，仅仅起到找到第一个有数据节点的作用。

②单向带头非循环链表

在这里插入图片描述

③单向不带头循环链表

在这里插入图片描述

④单向不带头非循环链表

在这里插入图片描述

⑤双向带头循环链表

双向链表的初始状态比较特殊：
在这里插入图片描述
一般状态：
在这里插入图片描述

⑥双向带头非循环链表

在这里插入图片描述

⑦双向不带头循环链表链表

在这里插入图片描述

⑧双向不带头非循环链表

在这里插入图片描述
下面重点介绍单向不带头非循环链表和双向双向不带头非循环链表

单链表

一、🌞链表的基本介绍

链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
而单链表有一个指针域，双链表有两个指针域。

二、🌞单链表的接口实现

2.1💡单链表结构的定义

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;//存数据
	struct SListNode* next;//指向下一个结点
}SLTNode;

2.2💡单链表结点创建

从顺序表我们可以知道每次加数据都要申请结点，所以我们创建个申请结点的函数，需要结点就调用此函数。

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

2.3💡单链表的插入

先在主函数创建个结构体指针

SLTNode* plist = NULL;

想要操作就进行传址操作

2.3.1📍头插
void SListPushFront(SLTNode** pplist, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pplist;
	*pplist = newnode;
}

我们知道传进来的是指向链表起始位置的指针，所以如图插入
在这里插入图片描述
从这个图可以看出传址的重要性，如果是传值，pplist只会在拷贝的空间指向首地址，并不能改变原来的地址。

2.3.2📍尾插

这里我们发现要先找到尾部才能插入下一个结点
在这里插入图片描述

void SListPushBack(SLTNode** pplist, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);
	//找到尾
	SLTNode* cur = *pplist;
	while (cur->next != NULL)
	{
		cur = cur->next;
	}
	cur->next = newnode;
}

这代码里有个bug不知道大家看出来没有
如果此时链表一个元素都没有cur就是空指针，对cur进行操作就成了野指针！！！
所以要判断一下：

void SListPushBack(SLTNode** pplist, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);
	if (*pplist == NULL)
	{
		pplist = newnode;
	}
	else
	{
		//找到尾
		SLTNode* cur = *pplist;
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		cur->next = newnode;
	}
}
2.3.3📍指定位置插入
2.3.3.1📍在pos前插入

此时我们需要找到pos前的一个结点才能够相连。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

但是我们经过上面的错误可得知要先判断pos是不是首结点

void SListInsertBefore(SLTNode** pplist, SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode= BuySLTNode(x);
	//在第一个位置前插
	if (pos == *pplist)
	{
		newnode->next = *pplist;
		*pplist = newnode;
	}
	else
	{
		//找到前一个结点位置
		SLTNode* prev = *pplist;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
}
2.3.3.2📍在pos后插入
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

这里就不用考虑是不是最后一个了，没有影响。

2.4💡单链表的删除

2.4.1📍头删

头指针移动到第二个元素的地方，释放掉原头指针指向的结点。

void SListPopFront(SLTNode** pplist)
{
	//要有元素可删
	assert(*pplist);
	SLTNode* next = (*pplist)->next;
	free(*pplist);
	*pplist = next;
}
2.4.2📍尾删

还是跟尾插一样要找到尾。
但是要考虑到没有结点和只有一个结点的情况
如果是多个结点，要找到尾部和尾部的前一个结点
在这里插入图片描述

void SListPopBack(SLTNode** pplist)
{
	//要有元素可删
	assert(*pplist);
	//只有一个结点
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	
	SLTNode* prev = NULL;
	SLTNode* tail = *pplist;
	while (tail->next != NULL)
	{
		prev = tail;
		tail = tail->next;
	}
	free(tail);
	prev->next = NULL;
}
2.4.3📍指定位置删除

在指定的位置删除也是要找到删除结点的前一个结点
在这里插入图片描述

void SlistEraseCur(SLTNode** pplist, SLTNode* pos)
{
	assert(pos);
	//要有结点删
	assert(*pplist);
	//头删
	if (*pplist == pos)
	{
		SListPopFront(*pplist);
	}
	else
	{
		SLTNode* cur = *pplist;
		SLTNode* prev = NULL;
		while (cur != pos)
		{
			prev = cur;
			cur = cur->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

2.5💡单链表的查找

遍历找相同的结点里的数据，相同就返回对应的指针，没找到就返回NULL。

SLTNode* SListFind(SLTNode** pplist, SLTDataType x)
{
	SLTNode* cur = *pplist;
	//遍历链表
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

2.6💡单链表的打印

void SListPrint(SLTNode* plist)
{
	SLTNode* cur = plist;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

2.7💡单链表的销毁

void SListDestroy(SLTNode** pplist)
{
	SLTNode* cur = *pplist;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pplist = NULL;
}

双向链表

一、🌞双向链表的基本介绍

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

二、🌞双向链表的优缺点

跟单链表相比双向链表多了个可以指向前一个结点的指针，我们发现单链表在指定位置前插入结点时要遍历到前一个位置，而双向链表就不用遍历，直接用前指针就好了。虽然结构比单链表复杂，但是用起来很方便。
下面就把双向链表最复杂的结构双向带头循环链表实现一下。

三、🌞双向链表的接口实现

3.1💡双向链表的结构定义

typedef int LTDateType;

typedef struct ListNode
{
	struct ListNode* prev;
	struct ListNode* next;
	LTDateType date;
}ListNode;

3.2💡双向链表结点的创建

ListNode* BuyListNode(LTDateType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->next = NULL;
	newnode->date = x;
	newnode->prev = NULL;
	return newnode;
}

3.3💡双向链表的初始化

因为我们要创建的是带哨兵位的双向链表，所以要创建个哨兵位。
在这里插入图片描述

ListNode* ListInit()
{
	ListNode* phead = BuyListNode(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

3.4💡双向链表的插入

3.4.1📍尾插

在这里插入图片描述
从图中可以看出尾部很好找，就是哨兵位的前驱位。

void ListPushBack(ListNode* phead, LTDateType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	//找尾
	ListNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

最后四步是为了让插入后结构还是保持原样。

3.4.2📍头插

其实头插跟尾插换汤不换药，实现的方式一样：

void ListPushFront(ListNode* phead, LTDateType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	ListNode* first = phead->next;
	{
			newnode->next = first;
			first->prev = newnode;
			newnode->prev = phead;
			phead->next = newnode;
	}
}
3.4.3📍任意位置插入

把上面的头插尾插综合一下很容易能想到：

void ListInsert(ListNode* pos, LTDateType x)
{
	assert(pos);
	ListNode* newnode = BuyListNode(x);
	struct ListNode* prev = pos->prev, *next = pos;
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = next;
	next->prev = newnode;
}

根据上面的经验，头插尾插都可以调用这个接口来代替。

3.5💡双向链表的删除

3.5.1📍尾删

尾部删除的时候要注意如果只有一个哨兵位就不做处理

void ListPopBack(ListNode* phead)
{
	assert(phead);
	ListNode* tail = phead->prev, * prev = tail->prev;
	//不能删除哨兵位
	if (tail != phead)
	{
		free(tail);
		phead->prev = prev;
		prev->next = phead;
	}
}
3.5.2📍头删
void ListPopFront(ListNode* phead)
{
	assert(phead);
	ListNode* del = phead->next, * next = del->next;
	//不能删哨兵位
	if (del != phead)
	{
		free(del);
		phead->next = next;
		next->prev = phead;
	}
}
3.5.3📍任意位置删除

找到目标结点的前一个和后一个连接就行。

void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* prev = pos->prev, * next = pos->next;
	prev->next = next;
	next->prev = prev;
}

3.6💡双向链表的打印

void ListPrint(ListNode* phead)
{
		assert(phead);
		ListNode* cur = phead->next;
		while (cur != phead)
		{
			printf("%d ", cur->date);
			cur = cur->next;
		}
		printf("\n");
}

3.7💡双向链表的判空

就是判断双向链表是不是除了哨兵位就没有节点了，空返回 1， 非空返回0.

bool ListEmpty(ListNode* phead)
{
	return phead->next == phead;
}

3.8💡双向链表的销毁

void ListDestroy(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		ListNode* del = cur;
		cur = cur->next;
		free(del);
	}
	free(phead);
	phead = NULL;
}

这里要注意最后的 phead = NULL不起作用，因为是传值操作。为了保持接口一致性，就不传址了，在销毁函数运行后手动置空。

命由己造～
关注
  • 66
    点赞
  • 踩
  • 55
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 94
    评论
专栏目录
顺序表与链表
m0_56931704的博客
09-06 1400
顺序表与链表 一.顺序表 1.定义：将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。采用顺序存储结构的线性表简称为“ 顺序表”。 顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中 顺序表可以分为静态顺序表和动态顺序表 2.结构定义： #define MAXSIZE 100 typedef int ElemType; typedef struct Seqlist {//静态顺序表 ElemType data[MAXSIZE]; size_t size
【数据结构】顺序表和链表详解
m0_62934529的博客
04-28 3364
1. 线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2. 顺序表 2.1 概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表的物理结构和逻辑结构是
顺序表和链表
passion
08-03 2889
顺序表和链表的简单介绍和实现
数据结构---顺序表，链表
includeevey的博客
08-03 2334
2w字带你走进链表
顺序表&链表超全大总结
yue152152的博客
03-29 1748
线性表 线性表是n个具有形同特性的数据元素的有限序列。常见的线性表：顺序表、链表、栈，队列、字符串……本文重点讲解顺序表和链表，其他结构可见数据结构专栏的其他内容 注意：线性表在逻辑上是线性结构，也就是说是连续的但在物理结构上。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 顺序表 概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可分为静态顺序表和动态顺序表
数据结构顺序表和链表（超详细）
08-14
创建返回链表的头结点.// 双向链表销毁// 双向链表打印// 双向链表尾插// 双向链表尾删// 双向链表头插// 双向链表头删// 双向链表查找// 双向链表在pos的前面进行插入// 双向链表删除pos位置的结点
数据结构顺序表和链表的相关操作
06-30
实现顺序表和链表的建立、取元素、修改元素、插入、删除等顺序表的基本操作。 设计要求: 首先设计一个含有多个菜单项的主菜单程序，然后再为这些菜单项配上相应的功能。 基本操作： 1.依次从键盘读入数据，建立...
顺序表和链表.pdf
最新发布
04-24
顺序表和链表
数据结构实验 顺序表和链表
10-08
数据结构实验 顺序表和链表
8.顺序表和链表1
08-03
11. 给定一个链表，返回链表开始入环的第一个节点。12. 其他 。ps：链表的题当前因为难度及知识面等等原因还不适合我们当前学习，以后大家自己下去以后 [Le
数据结构之顺序表和链表
lang_965的博客
08-10 1288
本文用通俗易懂的方式详细讲解了顺序表和链表，是数据结构的精品讲解内容，适合大学在校生和自学的社会人士使用。
顺序表&链表 知识点总结
qq_51471471的博客
11-04 372
线性表之顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。并在数组上完成数据的增删查改 // 顺序表的动态存储 typedef struct SeqList { SQDataType* arr; // 指向动态开辟的数组 size_t size; // 数组中有效元素的个数 size_t capacity; // 数组的最大容量 }SeqList; 使用realloc()函数进行扩容 初始条件，结束条件，迭代过程 顺序表 经典OJ题 给定一个
链表和顺序表的总结
LoveHoneyYou的博客
05-02 626
顺序表： 优点： 1）支持随机访问，需要随机访问结构的算法可以很好的应用 2）cpu高速缓存命中率更高 缺点： 1）头部中部插入时间效率低 O(N) 2) 连续的物理空间，空间不够了以后需要增容，增容有一定程度消耗 3） 为了避免频繁增容，一般我们都按倍数去增容，用不完存在一定的空间浪费 链表（带头双向循环链表） 优点： 1）任意位置插入删除效率高 O(1) 2) 按需申请释放空间 缺点： 1）不支持随机访问（用下标访问）意...
链表面试题（1）----顺序表和链表的区别及其优缺点
baidu_39630193的博客
08-01 1万+
1.顺序表存储（典型的数组）      原理：顺序表存储是将数据元素放到一块连续的内存存储空间，相邻数据元素的存放地址也相邻（逻辑与物理统一）。      优点：（1）空间利用率高。（局部性原理，连续存放，命中率高）             （2）存取速度高效，通过下标来直接存储。      缺点：（1）插入和删除比较慢，比如：插入或者删除一个元素时，整个表需要遍历移动元素来重新排一次顺序
顺序表和链表的总结
weixin_53946312的博客
04-18 243
顺序表和链表（双向带头循环）的优缺点对比 *顺序表的优点 按下标进行随机访问 cpu高速缓存命中率比较高（物理空间是连续的） 顺序表的缺点： 空间不够需要增容，（一定程序的行能消耗）可能存在一定的空间浪费 在头部或中间插入删除数据，效率比较低O(N) 链表的优点： 按需申请内存，需要一个数据就申请一块内存，也不存在空间浪费 任意位置O（1）时间内插入，删除数据 链表的缺点 不支持下标的随机访问 ...
顺序表与链表基本定义
fighting123678的博客
07-17 2136
一、选择题 1、 2、
顺序表&链表
sting
07-29 1286
1.线性表 概念：有n（n &amp;gt;= 0）个数据元素组成的有限序列 性质： 1）可以在其任意位置上进行插入和删除操作的线性数据结构 2）线性表中的数据存在一对一的关系，即除第1个元素和最后一个元素外，每个元素都有唯一的直接前驱和后继。而第1个元素没有前驱，最后一个元素没有后继。 2.顺序表 概念：用一段地址连续的存储单元依次存储数据元素的线性结构 模型图： 动态...
经典面试题之顺序表和链表的优缺点
热门推荐
HanSion.Z
04-14 2万+
★什么是顺序表？顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组连续地址的存储单元依次存储数据元素的线性结构。表中的任一元素的地址都可以通过这个公式得到：LOC（di）=LOC（d1）+（i-1）*L 　1≤i≤n 其中，L是元素占用存储单元的长度。                              ★什么是链表？链表是一种链式存储的数据结构，用一组地址任意的存储单元存放线性表中...
数据结构顺序表和链表
09-06
常用的链表结构有无头单向非循环链表和带头双向循环链表。链表的优点是插入和删除元素时只需要修改指针的指向，时间复杂度为O(1)，但访问链表的某个元素需要从头开始遍历，时间复杂度为O(n)。 因此，顺序表适用于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

命由己造～

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值