单链表增删查找的实现

序言：什么是链表？

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

单链表是什么样的形式？下面这张图很清楚的展示了单链表的形式。

单链表需要注意的地方：

1. 从图中可以看出，链式结构在逻辑上是连续的，但是在物理上不一定是连续的；

2.现实中的节点一般都是从堆上申请出来的；

3.从堆上申请的空间，是按照一定的策略分配的，两次申请的空间可能连续，也可能不连续。

 单链表的实现：

首先啊！需要一个结构体；像这样：

typedef struct SeqList
{
	int val;
	struct SeqList* next;
}SL;

每一个这样的结构体都是一个节点；一个一个节点用指针连在一起就构成了我们的单链表；

首先，我们想要进行插入就意味着 我们先构造一个动态申请节点的函数；BuySLTNode(int x)

BuySLTNode(int x)
{
    SL*newnode = (SL*)malloc(sizeof(SL));//申请一个节点
    if(newnode == NULL)                    // 判断节点是否为空
    {
        perror("malloc fail");
        
    }
    newnode->val = x;
    newnode->next = NULL;
    return newnode;
}

 接下来就是插入 

在插入之前 我们先来写一个打印链表的函数：

void SLPrintf(SL* phead)
{
    SL*cur = phead;
    while(cur != NULL)
    {
        printf("%d->",cur->val);
        cur = cur -> next;
    }
    printf("\n");
}

现在进行我们的插入 单链表比较适合头插； 为什么呢？ 等下我们把头插 尾插 都实现我们对比一下。

头插：

SL* list = NULL;
SLPushFront(&list,1);   //我们这里传入的是 指针的地址
SLPushFront(&list, 2);
SLPrintf(list);


void SLPushFront(SL** pphead ,int x)  // 所以我们这里 要用二级指针
{
    assert(pphead);
	// 只要是插入 就要新建节点
	SL* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

尾插：

void SLPushBack(SL** pphead, int x)
{
	assert(pphead); 
	SL* newnode = BuySLTNode(x);
	SL* cur = *pphead;
	while (cur->next != NULL)
	{
		cur = cur->next;
	}
	cur->next = newnode;
}

对比以上两种插入 我们可以发现 尾插 的效率并没有 头插的效率高。尾插需要遍历链表，时间复杂度尾O(N) ,而头插 的时间复杂度 为O(1);

下面我们进行 删除；

头删：

//头删
void SLPopFront(SL** pphead)
{
	//已经为空了再删
	//需要检查
	if (*pphead == NULL)
	{
		return;
	}
 	SL* del = *pphead;
	*pphead = (*pphead)->next;
	free(del);
	del = NULL;
}

尾删：

尾删就相对更加复杂了；需要考虑很多种情况；

void SLPopBack(SL** pphead)
{
	assert(pphead);
// 1.链表为空时
	if (*pphead == NULL)
	{
		return;
	}
// 2.链表中只有一个节点
	else if ((*pphead)->next == NULL)
	{
		free(*pphead);
	}
// 3.正常情况
	else
	{
		SL* cur = *pphead;
		while (cur->next->next != NULL)
		{
			cur = cur->next;
		}
		free(cur->next);
		cur->next = NULL;
	}
}

查找链表中的数

SLTNode* SLFind(SLTNode* phead, SLTDateType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->date = x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return -1;
}

在 Pos 位置之前插入一个节点；

void SListInsertBefore(SLTNode** pphead,SLTNode*Pos,SLTDateType x)
{
	assert(pphead);
	assert(Pos);
	if (*pphead == Pos)
	{
		SLPopFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != Pos)
		{
			prev = prev->next;
			if (prev->next == NULL)
			{
				break;
			}
		}
		SLTNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = Pos;
	}
}

在 Pos 位置之后插入一个节点；

void SListInsertAfter(SLTNode* Pos, SLTDateType x)
{
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = Pos->next;
	Pos->next = newnode;
}

在删除Pos这个节点；

void SLErase(SLTNode** pphead, SLTNode* Pos)
{
	assert(pphead);
	assert(Pos);
	if (*pphead == Pos)
	{
		SLPopBack(pphead);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next != Pos)
		{
			cur = cur->next;
			if (cur->next == NULL)
			{
				break;
			}
		}
		cur->next = cur->next->next;
		free(Pos);
		Pos = NULL;
	}
}