链表——单链表

前言:顺序表的优点在于查找元素方便，但是增删元素需要移动大量元素，对于链表而言，它所占的空间大小和位置是不需要预先分配划定的，可以根据系统的情况和实际的需求即时生成

链表

（1）概念

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

（2）链表的分类：八种

单向或双向链表；

带头或不带头链表；循环或非循环链表；

无头单向非循环链表；带头双向循环链表；

其中用的最多的还是无头单向非循环换链表和带头双向循环链表，前者一般不会单独存储数据，是其他数据结构的子结构，像哈希表、图的邻接表等等

（3）无头单向非循环链表的几个基本操作

//无头单向非循环链表
头文件
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SLNode;
// 动态申请一个结点
SLNode* CreatNode(SLTDateType x);
// 单链表打印
void SLNodePrint(SLNode* plist);
// 单链表尾插
void SLNodePushBack(SLNode** pphead, SLTDateType x);
// 单链表的头插
void SLNodePushFront(SLNode** pphead, SLTDateType x);
// 单链表的尾删
void SLNodePopBack(SLNode** pphead);
// 单链表头删
void SLNodePopFront(SLNode** pphead);
// 单链表查找
SLNode* SLFind(SLNode* phead, SLTDateType x);
// 单链表在pos位置之后插入x
void SLInsertAfter(SLNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SLEraseAfter(SLNode* pos);
//在pos位置之前插入
void SLInitFront(SLNode** pphead, SLNode* pos, SLTDateType x);
//在pos位置删除
void SLErase(SLNode** pphead, SLNode* pos);


#include "SList.h"

//单链表的打印
void SLNodePrint(SLNode* phead)
{
	SLNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

//创建一个新结点
SLNode* CreatNode(SLTDateType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

//尾插
void SLNodePushBack(SLNode** pphead, SLTDateType x)
{
	SLNode* newnode = CreatNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;

	}
}

//头插
void SLNodePushFront(SLNode** pphead, SLTDateType x)
{
	SLNode* newnode = CreatNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

//尾删
void SLNodePopBack(SLNode** pphead)
{
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}

}

//头删
void SLNodePopFront(SLNode** pphead)
{
	assert(*pphead);
	SLNode* tail = *pphead;
	*pphead = (*pphead)->next;
	free(tail);
	tail = NULL;
}

//查找
SLNode* SLFind(SLNode* phead, SLTDateType x)
{
	SLNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

//在pos位置后插入
void SLInsertAfter(SLNode* pos, SLTDateType x)
{
	assert(pos);
	SLNode* newnode = CreatNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

//在pos位置后删除
void SLEraseAfter(SLNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

//在pos位置之前插入
void SLInitFront(SLNode** pphead, SLNode* pos, SLTDateType x)
{
	assert(pos);
	assert(pphead);
	if (*pphead == pos)
	{
		SLNodePushFront(pphead, x);
	}
	else
	{
		SLNode* newnode = CreatNode(x);
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
}

//在pos位置删除
void SLErase(SLNode** pphead, SLNode* pos)
{
	assert(*pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SLNodePopFront(pphead);
	}
	else
	{
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}