数据结构之单向不带头不循环链表

一、链表的概念及结构

1.链表的概念

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

2.链表的结构

链表

在现实的数据结构中：

注意
1.从图上看出，链式结构在逻辑上是连续的，但在物理上不一定连续
2.现实中的节点都是从堆上申请出来的
3.在堆上申请的空间，是按照一定策略分配的，两次连续申请空间，有可能连续也有可能不连续。

3.链表的分类

1.单项或者双向链表

2.带头或者不带头单链表

3.循环或者非循环链表

4.最常用到的

• 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
• 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

二、链表的实现

杂项

• 结构

typedef int SLTDataType;
typedef struct SListTNode
{
	int data;
	struct SListTNode* next;
}SLTNode;

• 链表打印

void SLPrint(SLTNode* phead);

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

• 申请空间
  

SLTNode* BuySLTNode(SLTDataType x);

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

1.头插

void SListPushFront(SLTNode** pphead, SLTDataType x);

void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

2.尾插

void SListPushBack(SLTNode** pphead, SLTDataType x);

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

3.尾删

void SListPopBack(SLTNode** pphead);

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);
	//1个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//多个节点
	{
		SLTNode* cur = *pphead;
		while (cur->next->next)
		{
			cur = cur->next;
		}
		free(cur->next);
		cur->next = NULL;
	}
}

4.头删

void SListPopFront(SLTNode** pphead);

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);

	SLTNode* del = *pphead;
	(*pphead) = (*pphead)->next;
	free(del);
	del = NULL;
}

5.查找

SLTNode* SListFind(SLTNode* phead, SLTDataType x);

SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

6.在pos位置之前插入

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
			assert(cur);
		}
		SLTNode* newnode = BuySLTNode(x);
		cur->next = newnode;
		newnode->next = pos;
	}
}

7.在pos后插入

void SListInsertAfter(SLTNode* pos, SLTDataType x);

void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	SLTNode* prev = pos->next;
	pos->next = newnode;
	newnode->next = prev;
}

8.删除pos位置节点

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

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SListPopFront(pos);//删除头部直接使用头删
	}
	else
	{
		SLTNode* cur = *pphead;
		SLTNode* prev = NULL;
		while (cur->next != pos)
		{
			cur = cur->next;
			assert(cur);
		}
		cur->next = pos->next;
		free(pos);
	}
}

9.删除pos后位置节点

void SListEraseAfter(SLTNode* pos);

void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SLTNode* cur = pos->next;
		pos->next= cur->next;
		free(cur);
	}
}

10.链表销毁

void SListDestory(SLTNode** pphead);

void SListDestory(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)//遍历销毁非常简单
	{
		SLTNode* prev = cur->next;
		free(cur);
		cur = prev;
	}
	*pphead = NULL;
}