链表的学习以及不带头节点的单链表的实现

1. 什么是链表？

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的，也就是说当我们知道一个元素的指针，我们可以通过它去寻找到下一个元素的位置，以此类推。

相比较于前面所学的顺序表，在某些方面链表更为高效。比如：由于链表在物理存储上非连续，所以可以更有效的利用内存的碎片空间，并且链表的的某些操作，时间复杂度也相对更少。下面是用c语言来实现不带头单链表。

首先是头文件

#pragma once

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <malloc.h>
//不带头节点的单链表 
typedef int SDataType;

// 节点结构 
typedef struct SListNode
{
	SDataType _data;
	struct SListNode* _pNext;
}Node;


// 给一个链表结构 
typedef struct SList
{
	Node* _pHead;
}SList;


// 链表的初始化 
void SListInit(SList* pl);

// 在链表中尾插值为data的节点 
void SListPushBack(SList* pl, SDataType data);

// 删除链表最后一个节点 
void SListPopBack(SList* pl);

// 在链表第一个元素前插入值为data的节点 
void SListPushFront(SList* pl, SDataType data);

// 删除链表中第一个节点 
void SListPopFront(SList* pl);

// 在链表pos位置后插入置为data的节点 
void SListInsertAfter(Node* pos, SDataType data);

// 删除链表中pos位置的后一个节点 
void SListErase(SList* pl, Node* pos);

// 在链表中查找值为data的节点，找到返回该节点的地址，否则返回空 
Node* SListFind(SList* pl, SDataType data);

// 销毁链表 
void SListDestroy(SList* pl);

// 获取链表中有效节点的个数 
int SListSize(SList* pl);

// 检测链表是否为空 
int SListEmpty(SList* pl);

// 获取链表的第一个节点 
Node* SListFront(SList* pl);

// 获取链表的第二个节点 
Node* SListBack(SList* pl);

// 删除链表中第一个值为data的节点 
void SListRemove(SList* pl, SDataType data);

// 删除链表中所有值为data的节点 
void SListRemoveAll(SList* pl, SDataType data);

然后是函数实现部分

#define   _CRT_SECURE_NO_WARNINGS
#include"Slist.h"

// 链表的初始化 
void SListInit(SList* pl)
{
	assert(pl);
	pl->_pHead = NULL;
}

// 在链表中尾插值为data的节点 
void SListPushBack(SList* pl, SDataType data)
{
	assert(pl);
	Node* node = (Node*)malloc(sizeof(Node));
	node->_data = data;
	node->_pNext = NULL;
	if (pl->_pHead == NULL)
	{
		pl->_pHead->_data = data;
		pl->_pHead->_pNext = NULL;
		return;
	}
	Node* cur = pl->_pHead;
	while (cur->_pNext != NULL)
	{
		cur = cur->_pNext;
	}
	cur->_pNext = node;
}

// 删除链表最后一个节点 
void SListPopBack(SList* pl)
{
	assert(pl);
	assert(pl->_pHead != NULL);
	if (pl->_pHead->_pNext = NULL)
	{
		pl->_pHead = NULL;
		return;
	}
	Node* cur = pl->_pHead;
	while (cur->_pNext->_pNext != NULL)
	{
		cur = cur->_pNext;
	}
	free(cur->_pNext);
	cur->_pNext = NULL;

}

// 在链表第一个元素前插入值为data的节点 
void SListPushFront(SList* pl, SDataType data)
{
	Node* node = (Node*)malloc(sizeof(Node));
	node->_data = data;
	node->_pNext = pl->_pHead;
	pl->_pHead = node;
}

// 删除链表中第一个节点 
void SListPopFront(SList* pl)
{
	assert(pl);
	assert(pl->_pHead != NULL);
	Node* temp = pl->_pHead->_pNext;
	free(pl->_pHead);
	pl->_pHead = temp;
}

// 在链表pos位置后插入置为data的节点 
void SListInsertAfter(SList* pl, Node* pos, SDataType data)
{
	assert(pl);
	Node* node = (Node*)malloc(sizeof(Node));
	node->_data = data;
	node->_pNext = pos->_pNext;
	pos->_pNext = node;
}

// 删除链表中pos位置的后一个节点 
void SListErase(SList* pl, Node* pos)
{
	assert(pl);
	Node* node = pos->_pNext->_pNext;
	free(pos->_pNext);
	pos->_pNext = node;
}

// 在链表中查找值为data的节点，找到返回该节点的地址，否则返回空 
Node* SListFind(SList* pl, SDataType data)
{
	assert(pl);
	Node* cur = pl->_pHead;
	while (cur != NULL)
	{
		if (cur->_data == data)
		{
			return cur;
		}
		cur = cur->_pNext;
	}
}

// 销毁链表 
void SListDestroy(SList* pl)
{
	Node* cur = pl->_pHead;
	while (cur != NULL)
	{
		cur = cur->_pNext;
		free(cur);
	}
	pl->_pHead = NULL;
}

// 获取链表中有效节点的个数 
int SListSize(SList* pl)
{
	assert(pl);
	Node* cur = pl->_pHead;
	int ret = 0;
	while (cur != NULL)
	{
		ret++;
	}
	return ret;
}

// 检测链表是否为空 
int SListEmpty(SList* pl)
{
	if (pl->_pHead == NULL)
	{
		return 1;
	}
	return -1;
}

// 获取链表的第一个节点 
Node* SListFront(SList* pl)
{
	return pl->_pHead;
}

// 获取链表的第二个节点 
Node* SListBack(SList* pl)
{
	return pl->_pHead->_pNext;
}

// 删除链表中第一个值为data的节点 
void SListRemove(SList* pl, SDataType data)
{
	assert(pl);
	Node* cur = pl->_pHead;
	Node* temp = NULL;
	while (cur->_pNext != NULL)
	{
		if (cur->_pNext->_data == data)
		{
			temp = cur->_pNext->_pNext;
			free(cur->_pNext);
			cur->_pNext = temp;
			return;
		}
		cur = cur->_pNext;
	}
}

// 删除链表中所有值为data的节点 
void SListRemoveAll(SList* pl, SDataType data)
{
	assert(pl);
	Node* cur = pl->_pHead;
	Node* temp = NULL;
	while (cur->_pNext != NULL)
	{
		if (cur->_pNext->_data == data)
		{
			temp = cur->_pNext->_pNext;
			free(cur->_pNext);
			cur->_pNext = temp;
		}
		cur = cur->_pNext;
	}
	if (pl->_pHead->_data = data)
	{
		temp = pl->_pHead->_pNext;
		free(pl->_pHead);
		pl->_pHead = temp;
	}
}