数据结构 —— 链表之单链表

链表的概念及结构

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

【注意】：上图中可看出链表在指针的连接下是连续的，其实那是是单链表的逻辑结构，更符合人的设想。实际上，链表的节点一般是从堆上一次一次分别申请出来的，申请的空间可能连续也可能不连续，所以物理结构上链表不一定连续。

链表的分类

实际中链表的及结构还是挺多样的，以下情况组合起来就有8种链表结构：
1、单向或双向链表

2、带头 (哨兵位) 或不带头链表

3、循环或非循环链表

实际上最常用的只有其中的两种结构：

单链表接口

定义单链表

//定义单链表自定义类型
typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

单链表尾插

void SLTPushBack(SLTNode** pphead, SLTDataType x)  //为了可以更改实参头指针的值，所以使用二级指针
{
	//申请用于储存被插入数据的空间
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("SLPushBack malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//先找尾，再插入
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

单链表头插

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("SLPushBack malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;

	newnode->next = *pphead;
	*pphead = newnode;
}

单链表尾删

void SLTPopBack(SLTNode** pphead)
{
	assert(*pphead);
	
	if ((*pphead)->next == NULL)  //只有一个结点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else  //有多个节点
	{
		SLTNode* prev = NULL;      //新建一个指针，储存尾结点前一个结点的地址
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}

		free(tail);
		tail = NULL;
		prev->next = NULL;
	}
}

单链表头删

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

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

查找等于给定数据的节点

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;  //找到，返回该节点
		}
		cur = cur->next;
	}

	return NULL;  //未找到，返回空
}

pos结点之前插入

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

	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);  //复用头插
	}
	else
	{
		//找到pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
		if (newnode == NULL)
		{
			perror("SLPushBack malloc fail");
			return;
		}
		newnode->data = x;
		newnode->next = NULL;

		prev->next = newnode;
		newnode->next = pos;
	}
}

pos位置删除

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

	if (*pphead == pos)
	{
		SLTPopFront(pphead);  //复用头删
	}
	else
	{
		//记录pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = pos->next;
		free(pos);
	}
}

pos结点后面插入

//C++的STL实现的便是pos后面的插入和删除
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("SLPushBack malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;

	newnode->next = pos->next;
	pos->next = newnode;  //一定要先把pos的next插入newnode后面再改pos的next
}

pos位置后删除

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);  //pos后面必须有结点

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

链表销毁

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

	SLTNode* headnext = (*pphead)->next;
	while (*pphead)
	{
		free(*pphead);
		*pphead = headnext;

		if (headnext != NULL)
			headnext = headnext->next;
	}
}

顺序表和链表的区别