顺序表和链表

目录

1.线性表

2.顺序表

 2.1概念及结构

3.链表

3.1 链表的概念及结构

为什么有链表结构？

3.2 链表的分类

---

1.线性表

线性表 （ linear list ） 是 n 个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储

2.顺序表

 2.1概念及结构

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

数据从第一个开始，连续存放

顺序表一般可以分为：

1. 静态顺序表：使用定长数组存储元素。
2. 动态顺序表：使用动态开辟的数组存储。

优势：

   方便组织所需要的数据。（数据间物理空间上连续，支持下标随机访问）

缺点

    空间不够时，需要扩容。有一定性能消耗。其次一般扩容二倍，存在空间浪费

    头部或尾部删除插入效率低下

为了改善以上的不足，有以下的方案：（链表） 

1.按需申请释放空间。

2.头部或者中间插入删除，不需要挪动数据。

3.链表

3.1 链表的概念及结构

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

为什么有链表结构？

现实中 数据结构中

3.2 链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构

1. 单向或者双向

2. 带头或者不带头

3. 循环或者非循环

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

1. 无头单向非循环链表： 结构简单 ，一般不会单独用来存数据。实际中更多是作为 其他数据结 构的子结构 ，如哈希桶、图的邻接表等等。另外这种结构在 笔试面试 中出现很多。

2. 带头双向循环链表： 结构最复杂 ，一般用在单独存储数据。实际中使用的链表数据结构，都 是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

 n1->next=n2;

依次存入上一个指针的地址，最后一个存入空指针

打印：

在创建一个指针，指向头部地址，原因防止phead移动而丢失头部地址

void SListPrint(SLTNode* phead)//打印单链表的数据
{
	SLTNode* cur = phead;//在创建一个指针，指向头部地址，原因防止phead移动而丢失头部地址
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

尾插：

//可能会出现一个结点都不存在的情况，这样就找不到尾部 

 

void SListPushBack(SLTNode** pphead, SLTDataType x)//尾插
{
	SLTNode* newnode = BuySListNode(x);

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	//可能会出现一个结点都不存在的情况，这样就找不到尾部
	else
	{
		// 找尾节点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

SLTNode* BuySListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//malloc出来的结点不会销毁，只有指针newnode会销毁
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

尾删

 若出现要尾删的链表为空的情况需要单独考虑，因为无法找到NULL指针前面的那个指针，同样的只有一项的链表也要单独考虑

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	// 1、只有一个节点
	// 2、多个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		/*SLTNode* tailPrev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tailPrev = tail;
			tail = tail->next;
		}
		free(tail);
		tailPrev->next = NULL;*///如果没有tailprev那么最后尽管也能将最后一项删除却仍然将各个项联系在一起，导致仍有错误
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

头删

//防止链表本身为空//二级指针应该断言防止为空，这样就无法对其中进行删除等操作

void SListPopFront(SLTNode** pphead)//你只要想去改变plist你就要传递二级指针
{
	assert(*pphead != NULL);//防止链表本身为空//二级指针应该断言防止为空，这样就无法对其中进行删除等操作
	//if (*pphead == NULL)
	//	return;

	SLTNode* next = (*pphead)->next;//如果直接free掉头部，后面的所有将再也找不到，所以需要先存储下一个结点，
	free(*pphead);
	*pphead = next;
}

查找

SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;//一级指针无所谓，空指针也是可以查找的
	while (cur)
	{
		if (cur->data == x)
			return cur;

		cur = cur->next;
	}

	return NULL;
}

这种情况并不需要判断是否空，因为单纯查找并不需要改变plist

在pos前插入

//判断pos是否为空的同时也判断了链表是否为空 

//创建新的结点 

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)//在pos前插入
{
	assert(pos);//判断pos是否为空的同时也判断了链表是否为空
	assert(pphead);//

	// 头插
	if (pos == *pphead)//如果要在第一个位置前插入可能是头插
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;//寻找pos前面的一个位置
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SLTNode* newnode = BuySListNode(x);//创建新的结点
		prev->next = newnode;
		newnode->next = pos;
	}
}

删除pos位置的值

 pos=NULL并没有真实的意义，就算不赋值最终也将会销毁

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = pos->next;

		free(pos);
		pos = NULL;//其实没有效果，因为pos是一个形参，最后也被回收了
	}
}

单链表在pos位置之后插入x

 

 这种方式可以不考虑顺序；    

SLTNode* next = pos->next;//直接将pos->next指向newnode则会出现下下一项的地址找不到的情况，故创建一个指针提前存储可以有效处理

void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	/*SLTNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;*/

	// 不在乎链接顺序
	SLTNode* newnode = BuySListNode(x);
	SLTNode* next = pos->next;//直接将pos->next指向newnode则会出现下下一项的地址找不到的情况，故创建一个指针提前存储可以有效处理
	// pos newnode next
	pos->next = newnode;
	newnode->next = next;
}

删除pos下一个位置 

// 删除pos下一个位置
void SListEraseAfter(SLTNode* pos)
{
	assert(pos);

	if (pos->next == NULL)
		return;

	SLTNode* del = pos->next;
	//pos->next = pos->next->next;//写成这样的话pos后方位置无法free掉
	pos->next = del->next;

	free(del);
	del = NULL;
}

4.顺序表和链表的区别

顺序表优点：下标随机访问；

顺序表缺点：头部或者中部出入删除效率低，扩容(有一定程度性能消耗，可能存在一定程度空间浪费)

链表优点：任意位置插入删除为O(1)，按需申请释放

链表缺点：不支持下标随机访问。