【数据结构与算法】——单链表的基本操作

链表的定义和结构

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

基本操作

从图中可以看出，单链表的 链式结构在逻辑上是连续的，但是在物理上不一定连续，因为在现实中，结点一般是从堆上申请出来的，而从堆上申请的空间是按照一定策略来分配的，连续两次申请的空间可能连续也可能不连续。
此单链表的结构是，plist存放第一个结点的地址，每一个结点由两部分构成，一部分存储数据，一部是放指向下一个结点地址的指针

定义链表

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

由于next存放的是指向下一个结点地址的指针，所以next是结构体指针类型

打印链表

void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;

	}
	printf("NULL\n");
} 

这里将链表头部的地址存到cur里，目的是之后方便找到链表的头指针

创建节点

链表每插入一个数据都要创建一个结点，因此将该部分进行封装，之后的接口调用会更方便一些

SLTNode* BuySListNode(SLTDataType x)
{ 
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	if (node == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	node->data = x;
	node->next = NULL;
	return node;

}

尾插

尾插数据 ，只需要将尾部结点的next值改为要插入的结点的地址

常规情况，很多同学开始会这样写

void SListPushBack(SLTNode* phead, SLTDataType x)
{
    if (phead == NULL)
		{
			SLTNode* newnode = BuySListNode(x);
			phead = newnode;
		}
	else
	{ 
		SLTNode* tail = phead;//找尾
		while (tail->next)
		{
			tail = tail->next;
		}
		SLTNode* newnode = BuySListNode(x);
		tail->next = newnode;
	}
}

这种情况，在plist为空的情况下，如果不判断传入的指针是否为空，就会导致phead为空，进而tail为空，这样循环进不去，程序就会挂掉，所以要先判断是否为空指针，如果为空，就创建新结点。然而运行之后会出现这种情况：
并不会打印链表，直接输出一个空指针，经过调试后发现：phead已经指向新结点，但是plist并没有指向新结点

其实这里的原因就是plist指针传值造成的，也就是说，把plist指针里存的值传给里phead，那么phead改变，并不会对plist造成改变。要想改变plist的值，就要把plist的地址传上去，所以这里要用到二级指针。

正确的代码：

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

		}
		SLTNode* newnode = BuySListNode(x);
		tail->next = newnode;
	}
	
}

这里pphead存放的是plist的地址，*pphead是找到plist的值，也就是头指针的地址。

因此，要改变传过来的指向第一个结点的指针就传二级
不改变传过来的指向第一个结点的指针就传一级

头插

头插的原理很简单，创建一个新结点，把plist的值变成要头插结点的地址，然后把新结点的next改为下一个原来第一个结点的地址，其他的结点不变。这里要注意先后顺序，应先把plist的值传给新结点的next，然后再把新结点的地址传给plist，否则，先进行第二步，原来头指针的地址会被覆盖掉，就找不到了。

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

尾删

尾删：把最后一个结点删除，然后将倒数第二个结点的next值变为NULL
常规情况，同学一般会这样写：

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* tail = *pphead;
	while (tail->next)
	{
		tail = tail->next;
	}
	free(tail);
	tail = NULL;
}

这样写的缺点是，第三个结点的next值没有变为NULL.

第一个办法：用双指针，定义一个prev指针，用来指向tail之前的一个指针，tail每向后走之前，把tail的值给prev,这样当tail到达最后一个结点后，prev正好在倒数第二个结点，进而可以改变它的next值。

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		prev->next = NULL;
	}
}

第二个办法：由于单链表的特点是，在当前位置，找不到前一个结点，但是可以找到后一个结点，所以判断tail->next->next是否为空，若为空，那么tail->next就是尾，这时就可以让tail的next值指向NULL了

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);//没有结点直接报错
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}

}

这里解释一下这段代码：

if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}

当我们的链表一直调用尾删的时候，会出现这种情况：

调试一下会发现，prev会出现空指针的情况

假设现在只有一个节点：此时tail->next为空

	while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}

不会进入此循环 ，然后会free掉这个结点，然后把prev的next置空，然而此时prev就是一个空指针，所以最后会出现内存错误，因此要先判断一下是否只有一个结点，如果只有一个结点，直接free掉，然后把plist置空就可以了。

头删

头删：先把phead->next（也就是第二个结点的地址）存到newnode里，然后free掉头结点，最后把newnode传给plist。考虑多种情况，如果只有一个结点，这个程序一样成立。

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);//if else 可以直接合并 画图看
	SLTNode* newnode = (*pphead)->next;//一定要画图解释
	free(*pphead);
	*pphead = newnode;
}

计算结点的个数

int SListSize(SLTNode* phead)
{
	int size = 0;
	SLTNode* cur = phead;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

查找功能

SLTNode* SListFind(SLTNode* phead, SLTDataType x)//查找功能直接附带修改功能 
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	
	}
	return NULL;
}

查找功能自带了修改功能，因为找到链表中的数据后，就找到了当前结点，进而可以修改当前结点的数据

插入数据

第一种：在pos位置前插入

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)///先找到一个值 在这个值前面插入
{
	assert(pphead);
	assert(pos);//给的位置不能为空
	//1.头插
	if (*pphead == pos)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

在pos前插入需要传头结点，很麻烦，而在Pos后插入就不用，会简单很多
第二种：在pos后插入，需要注意传递结点地址的顺序

void SListInsertAfter(SLTNode* pos, SLTDataType x)//在后面插入更简单，不用传递头节点 但是先后顺序不能错
{
	assert(pos);
	SLTNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

删除Pos位置的数据

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	//1.头删
	//2.后面结点删除
	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *ppphead;
		while (prev->next != pos)//找到pos前一个结点
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL; 
	}

}

删除Pos位置的数据要找到pos之前的结点，进而要传头结点，很麻烦，但是删除pos后的结点就不用，很简单：

void SListEraseAfter( SLTNode* pos)
{
	assert(pos);
	assert(pos->next);//如果pos下一个是空也不能删除
	SLTNode* newnode = pos->next;
	pos->next = pos->next->next;
	free(newnode);
	newnode = NULL ;
}

最后，可以发现，在头文件里，这些只读的接口只需要传一级指针
而要进行对数据修改的接口，要传二级指针