• 数据结构——顺序表和链表

    目录

    线性表

    顺序表 

    顺序表的使用

    结构体的定义 

    数据的初始化 

    数据容量的检查 

    头部插入数据 

    头部删除数据 

    尾部插入数据 

    尾部删除数据 

     任意数据删除

    随机数据插入 

    数据查找 

    数据打印 

    数据修改 

    顺序表缺点 

    链表 

    结构体的创建 

    打印链表 

    新节点的建立 

     头部插入

    尾部插入 

     头部节点删除

    尾部节点删除

    节点的销毁 

    链表查找 

    随即插入

    后插 

    删除某节点前面的节点

    删除某节点后面的节点 

    线性表

     线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储

    链表

     

    顺序表 

     顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表就是数组

    1. 静态顺序表：使用定长数组存储元素。

     2. 动态顺序表：使用动态开辟的数组存储。

    1. typedef struct SeqList
    2. {
    3. SLDataType* array; // 指向动态开辟的数组
    4. size_t size ; // 有效数据个数
    5. size_t capicity ; // 容量空间的大小
    6. }SeqList;

    顺序表的使用

    结构体的定义 

    1. typedef int SLDatatype;
    2. typedef struct Sqelist
    3. {
    4. 	SLDatatype* a;//存储数据
    5. 	int size;//当前存储个数
    6. 	int capacity;//当前容量
    7. }SL;

    数据的初始化 

    1. void SLInit(SL *psl)
    2. {
    3. 	assert(psl);
    4. 	psl->a = NULL;
    5. 	psl->capacity = psl->size = 0;
    6. }

    数据容量的检查 

    1. void Checkcapacity(SL* psl)
    2. {
    3. 	if (psl->capacity == psl->size)
    4. 	{
    5. 		int newcapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
    6. 		SLDatatype* tmp = (SLDatatype*)realloc(psl->a, sizeof(SLDatatype) * newcapacity);
    7. 		if (tmp == NULL)
    8. 		{
    9. 			perror("realloc fail");
    10. 			return;
    11. 		}
    12. 		psl->a = tmp;
    13. 		psl->capacity = newcapacity;
    14. 	}
    15. }

    头部插入数据 

    1. void SLPpushfront(SL* psl, SLDatatype x)
    2. {
    3. 	assert(psl);
    4. 	Checkcapacity(psl);
    5. 	int end = psl->size - 1;
    6. 	while (end >= 0)
    7. 	{
    8. 		psl->a[end + 1] = psl->a[end];
    9. 		end--;
    10. 	}
    11. 	psl->a[0] = x;
    12. 	psl->size++;
    13. }

    头部删除数据 

    1. void SLPpopfront(SL* psl)//头删
    2. {
    3. 	assert(psl);
    4. 	if (psl->size == 0)
    5. 		return;
    6. 	int i = 0;
    7. 	for (i = 0; i < psl->size -1; i++)
    8. 	{
    9. 		psl->a[i] = psl->a[i + 1];
    10. 	}
    11. 	psl->size--;
    12. }//这里不能进行所任，缩容是需要代价的，缩容分俩种，一种原地缩，第二种异地找个新空间大小为缩后的大小，若后期要插入元素，则又要开辟空间，比较麻烦

    尾部插入数据 

    1. void SLPpopback(SL* psl)
    2. {
    3. 	assert(psl);
    4. 	if (psl->size == 0)
    5. 		return;
    6. 	psl->size--;
    7. }

    尾部删除数据 

    1. void SLPpopback(SL* psl)
    2. {
    3. 	assert(psl);
    4. 	if (psl->size == 0)
    5. 		return;
    6. 	psl->size--;
    7. }

     任意数据删除

    1. void SLErase(SL* psl, size_t pos)
    2. {
    3. 	assert(psl);
    4. 	assert(pos < psl->size);
    5. 	int i = 0;
    6. 	for (i = pos; i < psl->size - 1; i++)
    7. 	{
    8. 		psl->a[i] = psl->a[i + 1];
    9. 	}
    10. 	psl->size--;
    11. }

    随机数据插入 

    1. void SLInsert(SL* psl, int pos, SLDatatype x)
    2. {
    3. 	assert(psl);
    4. 	assert(pos <= psl->size);
    5. 	int i = 0;
    6. 	Checkcapacity(psl);
    7. 	for (i = psl->size; i >= pos; i--)
    8. 	{
    9. 		if (i == pos)
    10. 			psl->a[i] = x;
    11. 		else
    12. 			psl->a[i] = psl->a[i - 1];
    13. 	}
    14. 	psl->size++;
    15. }
    16. 	/*size_t end=pls->size-1;
    17. 	* while(end>=pos)
    18. 	* {
    19. 	* psl->a[end+1]=psl->a[end];
    20. 	* --end;
    21. 	* }
    22. 	* psl->a[pos]=x;
    23. 	* ++psl->size;
    24. 	* 这种写法 pos会隐式提升为size_t（unsigned int）类型
    25. 	* end 和 pos都为0之后，再--end，此时end变为一个非常大的数字
    26. 	* 注意这里的隐式提升
    27. 	* end和pos，俩个不能有一个是size_t类型，不然程序会出现错误
    28. 	*/

    数据查找 

    1. int SLPfine(SL* psl, SLDatatype x)
    2. {
    3. 	assert(psl);
    4. 	int i = 0;
    5. 	for (i = 0; i < psl->size; i++)
    6. 	{
    7. 		if (psl->a[i] == x)
    8. 			return i;
    9. 	}
    10. 	return -1;
    11. }

    数据打印 

    1. void SLPprint(SL* psl)
    2. {
    3. 	assert(psl);
    4. 	int i = 0;
    5. 	for (i = 0; i < psl->size; i++)
    6. 	{
    7. 		printf("%d ", psl->a[i]);
    8. 	}
    9. }

    数据修改 

    1. void SLModify(SL* psl, size_t pos, SLDatatype x)
    2. {
    3. 	assert(psl);
    4. 	assert(pos < psl->size);
    5. 	psl->a[pos] = x;
    6. }

    顺序表缺点 

    1. 中间/头部的插入删除，时间复杂度为O(N)

    2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

    3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到 200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。 

    链表 

    链表：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表 中的指针链接次序实现的 。 单链表不需要初始化

    结构体的创建 

    正确写法

    1. typedef  int SLTDataType;
    2. typedef struct SlistNode
    3. {
    4. 	SLTDataType data;
    5. 	struct SlistNode* next;
    6. }SLTNode;

    错误写法

    1. typedef struct SlistNode
    2. {
    3. 	SLTDataType data;
    4. 	struct SlistNode* next;
    5. 	//SLTNode*next;     错误写法，先有蛋还是先有鸡？
    6. 	// SlistNode* next; 错误写法，
    7. }SLTNode;
    1. typedef struct SlistNode
    2. {
    3. 	SLTDataType data;
    4. 	struct SlistNode* next;
    5. }SLTNode，*PSLNode;

    SLTNode*= PSLNode= struct SlistNode*,这三个等价

    打印链表 

    1. void SListprint(SLTNode* phead)
    2. {
    3. 	//phead可能会为空这里不需要断言
    4. 	SLTNode* cur = phead; 
    5. 	while (cur != NULL)
    6. 	{
    7. 		printf("%d->", cur->data);
    8. 		cur = cur->next;
    9. 	}
    10.  
    11. }

    新节点的建立 

    1. SLTNode* BuySLTnode(SLTDataType x)
    2. {
    3. 	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
    4. 	if (newnode == NULL)
    5. 	{
    6. 		perror("malloc fail");
    7. 		exit(-1);
    8. 	}
    9. 	newnode->data = x;
    10. 	newnode->next = NULL;
    11. return newnode；
    12. }

     需要新节点的地方会很多，建立一个新的函数专门建立节点

     头部插入

    创建新节点前，phead指向第一个节点 

    创建新节点：先让newnode->next指向phead, phead指向第一个节点的地址，也就是说新节点通过phead拿到了原来第一个节点的地址

    然后让phead指向新节点地址

    1. void SListpushfront(SLTNode* phead, SLTDataType x)
    2. {
    3. SLTNode newnode;//错误写法
    4. 	SLTNode* newnode =(SLTNode*) malloc(sizeof(SLTNode));
    5. }

     上面为错误代码不能用是因为：不能用局部节点，不然一出该函数就会被销毁，因此我们要用上面的函数来创建节点

     方式1：

    1. void SListpushfront(SLTNode* phead, SLTDataType x)
    2. {
    3. 	SLTNode* newnode = BuySLTnode(x);
    4. 	newnode->next = phead;
    5. 	phead = newnode;
    6. }

    运行后无法打印，这是因为我们在传参的时候没有传地址 ，因此在出建立节点的函数的时候会对形参销毁

    方式二，传地址

    1. SLTNode* plist=NULL;
    2. 	SListpushfront(&plist, 5);
    3. void SListpushfront(SLTNode**pphead, SLTDataType x)
    4. {
    5. 	SLTNode* newnode = BuySLTnode(x);
    6. 	newnode->next =*pphead;
    7. 	*pphead = newnode;
    8. }

    pphea存的是plist的地址，*pphead的plist=等号右边的值，可参考下图，此时能正常打印。

    尾部插入 

    先建立一个新的节点

    分为俩种情况，第一种头节点指向空，第二种头节点指向不为空 

    第一种情况：头节点为空，建立新的节点后，直接让头节点指向新节点

    第二种情况，头节点不为空，创建一个跟节点类型相同的结构体变量，然后让这个变量指向头节点，之后检查后面的每个节点，若有一个节点为的next为空，则在此处插入新节点

    tail发现这个节点的next指向为空，然后让这个节点的next指向下一个节点的地址，随着程序的结束tail也会随之消失

     

    1. void SListpushback(SLTNode** pphead, SLTDataType x)
    2. {
    3. 	//pphead不可能为空，pphead是plist的地址，pphead永远不为空
    4. 	//1.链表为空
    5. 	SLTNode* newnode = BuySLTnode(x);
    6. 	if (*pphead == NULL)
    7. 	{
    8. 		*pphead = newnode;
    9. 	}
    10. 	//2.不为空
    11. 	else
    12. 	{
    13. 		SLTNode* tail = *pphead;
    14. 		while (tail->next != NULL)
    15. 		{
    16. 			tail =tail->next;
    17. 		}
    18. 		tail->next = newnode;
    19. 	}
    20. }

    频繁的malloc会使效率降低

     头部节点删除

     

     

    1. void SListpopfront(SLTNode** pphead)//头删
    2. {
    3. 	SLTNode* del = *pphead;
    4. 	*pphead = (*pphead)->next;
    5. 	free(del);//删除第一个节点 
    6. 	del = NULL;
    7. }

    当全部删完后，plist指向NULL，此时就不能再删了。程序会崩溃，此时plsit为空，（*pphead）->next也为空，del也为空，因此加一个检查条件

    1. void SListpopfront(SLTNode** pphead)//头删
    2. {
    3. if（*pphead==NULL）
    4. {
    5. return;
    6. }
    7. 	SLTNode* del = *pphead;
    8. 	*pphead = (*pphead)->next;
    9. 	free(del);//删除第一个节点 
    10. 	del = NULL;
    11. }

    或

    1. void SListpopfront(SLTNode** pphead)//头删
    2. {
    3.     assert(*pphead！=NULL)；
    4. 	SLTNode* del = *pphead;
    5. 	*pphead = (*pphead)->next;
    6. 	free(del);//删除第一个节点 
    7. 	del = NULL;
    8. }

    尾部节点删除

     要判断尾部有一个节点还是多个节点甚至没有节点

    当tail->next为空，删除该节点，然后让前一个节点指向NULL 

    1. void SListpopback(SLTNode** pphead)
    2. {
    3. if(*pphead==NULL)
    4. return;
    5. if((*pphead)->next==NULL)
    6. {
    7. free(*pphead);
    8. *pphead=NULL;
    9. }
    10. else
    11. {
    12. 	SLTNode* prev = NULL;
    13. 	SLTNode* tail = *pphead;
    14. 	while (tail->next!= NULL)
    15. 	{
    16. 		prev = tail;
    17. 		tail = tail->next;
    18. 	}
    19. 	prev->next = NULL;
    20. 	free(tail);
    21. 	tail = NULL;
    22. }
    23. }

    或

    1. void SListpopback(SLTNode** pphead)
    2. {
    3. if(*pphead==NULL)
    4. return;
    5. if((*pphead)->next==NULL)
    6. {
    7. free(*pphead);
    8. *pphead=NULL;
    9. }
    10. else
    11. {
    12.  
    13. 	SLTNode* tail = *pphead;
    14. 	while (tail->next->next!= NULL)
    15. 	{
    16. 		tail = tail->next;
    17. 	}
    18. 	free(tail->next);
    19. 	tail->next = NULL;
    20. }
    21. }

    节点的销毁 

     

    释放掉cur,cur=next ，不断往下走，最后把头节点置空

    1. void SListDestory(SLTNode** pphead)//用二级指针会更好
    2. {
    3.  
    4. 	SLTNode* cur = *pphead;
    5. 	while (cur)
    6. 	{
    7. 		SLTNode* next = cur->next;
    8. 		free(cur);
    9. 		cur = next;
    10. 	}
    11. 	*pphead = NULL;
    12. }

    链表查找 

    1. SLTNode *SListFind(SLTNode** pphead, SLTDataType x)
    2. {
    3. 	SLTNode* cur = *pphead;
    4. 	while (cur != NULL)
    5. 	{
    6. 		if (cur->data == x)
    7. 		{
    8. 			return cur;
    9. 		}
    10. 		cur = cur->next;
    11. 	}
    12. 	return NULL;
    13. }

    挨个查找。

    随即插入

    1. void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
    2. {
    3. 	assert(pos);
    4. 	if (pos == *pphead)
    5. 	{
    6. 		SListpushfront(pphead, x);
    7. 	}
    8. 	else
    9. 	{
    10. 		SLTNode* prve = *pphead;
    11. 		while (prve->next != pos)
    12. 		{
    13. 			prve = prve->next;
    14. 			assert(prve);//找不到
    15. 		}
    16. 		SLTNode* newnode = BuySLTnode(x);
    17. 		prve->next = newnode;
    18. 		newnode->next = pos;
    19. 	}
    20. }

     从一个数的前面插入，若果头插则用头插函数

    后插 

    1. void SListInsertAfter(SLTNode** pphead, SLTNode* pos, SLTDataType x)
    2. {
    3. 	SLTNode* newnode = BuySLTnode(x);
    4. 	newnode->next = pos->next;
    5. 	pos->next = newnode;
    6. }

    删除某节点前面的节点

    1. void SlistErase(SLTNode** pphead, SLTNode* pos)
    2. {
    3. 	assert(pos);
    4. 	if (*pphead == pos)
    5. 	{
    6. 		SListpopfront(pphead);
    7. 	}//如果是头删，用头删函数
    8. 	else
    9. 	{
    10. 		SLTNode* prev = *pphead;
    11. 		if (prev->next != pos)
    12. 		{
    13. 			prev = prev->next;
    14. 			assert(prev);//判断pos是否属于本链表
    15. 		}
    16. 		prev->next = pos->next;
    17. 		free(pos);
    18. 		pos = NULL;
    19. 	}
    20. }

    删除某节点后面的节点 

    1. void SlistEraseAfter(SLTNode** pphead, SLTNode* pos)
    2. {
    3. 	assert(pos);
    4. 	if (pos->next == NULL)
    5. 		return;
    6. 	else
    7. 	{
    8. 		SLTNode* prev = *pphead;
    9. 		prev = pos->next;
    10. 		pos->next = prev->next;
    11. 		free(prev);
    12. 		prev = NULL;
    13. 	}
    14. }

    单链表缺陷

    单链表只适合头插头删，O(1)。

    替换法删除节点

    删除某个节点，要求是O(1)

    把2所在节点删除，可采用以下方法， 我们把2，3进行交换

     

     然后让3指向4

    缺陷：所删节点不能是尾节点，尾节点后面是空的，无法交换

    思路延申

    在pos之前插入，要求是O(1)

     我们不在之前插入，在之后进行插入

     

    然后交换值 

     

     

  • 相关阅读:
    java计算机毕业设计农田节水灌溉监测系统源码+系统+数据库+lw文档+mybatis+运行部署
    unity2022版本 实现加减进度条
    70个必备的数据分析工具
    站群服务器的特性和好处是什么
    【Effect C++ 笔记】（四）设计与声明
    Redis-cluster集群详细部署配置--有手就行
    【vue2第十章】data数据与组件间通信
    Java中的字节流和字符流如何理解——精简
    Hexagon_V65_Programmers_Reference_Manual（41）
    asp.net心理健康管理系统VS开发sqlserver数据库web结构c#编程计算机网页项目
  • 原文地址：https://blog.csdn.net/weixin_49449676/article/details/126015698