单链表的操作实现

实现单链表的操作函数 

头文件实现：
// 值类型
typedef int DataType;

typedef struct SListNode {
DataType data; // 值
struct ListNode *pNext; // 指向下一个结点
} SListNode;

源文件实现：
// 初始化
void SListInit(SListNode **ppFirst);

// 尾部插入
void SListPushBack(SListNode** ppFirst, DataType data);

// 头部插入
void SListPushFront(SListNode **ppFirst, DataType data);

// 尾部删除
void SListPopBack(SListNode **ppFirst);

// 头部删除
void SListPopFront(SListNode **ppFirst);

// 给定结点插入，插入到结点前
void SListInsert(SListNode **ppFirst, SListNode *pPos, DataType data);

// 给定结点删除
void SListErase(SListNode **ppFirst, SListNode *pPos);

// 按值删除，只删遇到的第一个
void SListRemove(SListNode **ppFirst, DataType data);

// 按值删除，删除所有的
void SListRemoveAll(SListNode **ppFirst, DataType data);

// 销毁
void SListDestroy(SListNode **ppFirst);

// 按值查找，返回第一个找到的结点指针，如果没找到，返回 NULL
int SListFind(SListNode *pFirst, DataType data); 

.h文件         

#pragma once//防止头文件重定义

#include<stdio.h>
#include<Windows.h>
#include<assert.h>

typedef int DataType;

typedef struct SLinkListNode{
	struct SLinkListNode *pNext;
	DataType date;
}SLinkListNode;

.c文件

#include"sLinkList.h"

// 初始化 
void SLinkListInit(SLinkListNode **ppFirst)
{
	assert(ppFirst);
	*ppFirst = NULL;
}

//销毁
void SLinkListDestroy(SLinkListNode **ppFirst)
{
	assert(*ppFirst);
	SLinkListNode *pNode, *pNextNode;
	pNode = *ppFirst;
	while (pNode->pNext->pNext){
		pNextNode = pNode->pNext;
		free(pNode);
		pNode = pNextNode;
	}
}

SLinkListNode *CreatNewNode(DataType data)
{
	SLinkListNode *pNewNode = (SLinkListNode *)malloc(sizeof(SLinkListNode));
	assert(pNewNode);
	pNewNode->date = data;

	return pNewNode;
}

// 尾部插入 
void SLinkListPushBack(SLinkListNode **ppFirst, DataType data)
{
	/*
	1、申请新结点空间
		data = data
		pNext = NULL
	2、找到当前最后一个结点
	3、将最后一个结点的pNext指向新结点空间	
	*/
	assert(ppFirst);

	SLinkListNode *pNewNode = CreatNewNode(data);

	pNewNode->pNext = NULL;

	SLinkListNode *pNode;
	pNode = *ppFirst;
	while (pNode->pNext){
		pNode = pNode->pNext;
	}
	pNode->pNext = pNewNode;
}

// 头部插入 
void SLinkListPushFront(SLinkListNode **ppFirst, DataType data)
{
	/*
	1、申请新结点空间
		data = data
		pNext = *ppFirst
	2、*ppFirst = 新空间
	*/
	assert(ppFirst);
	SLinkListNode *pNewNode = CreatNewNode(data);
	pNewNode->pNext = *ppFirst;
	*ppFirst = pNewNode;
}

// 给定结点插入，插入到结点前 
void SLinkListInsert(SLinkListNode **ppFirst, SLinkListNode *pPos, DataType data)
{
	/*
	1、申请新结点空间
	data = data
	pNext = pPos
	2、找到pPos的前一个结点
	*/
	assert(ppFirst);
	SLinkListNode *pNewNode = CreatNewNode(data);
	pNewNode->pNext = pPos;

	SLinkListNode *pNode;
	pNode = *ppFirst;
	while (pNode->pNext != pPos){
		pNode = pNode->pNext;
	}
	pNode->pNext = pNewNode;
}

//头删
void PopFront(SLinkListNode **ppFirst)
{
	assert(ppFirst);
	SLinkListNode *pOldNode = *ppFirst;

	*ppFirst = (*ppFirst)->pNext;
	free(pOldNode);
}

//尾删
void PopBack(SLinkListNode **ppFirst)
{
	assert(ppFirst);
	assert(*ppFirst);//空链表的情况

	//只有一个结点的情况
	if (!((*ppFirst)->pNext)){
		free(*ppFirst);
		*ppFirst = NULL;
		return;
	}

	SLinkListNode *pNode;
	pNode = *ppFirst;
	while (pNode->pNext->pNext){
		pNode = pNode->pNext;
	}
	free(pNode->pNext);
	pNode->pNext = NULL;
}

//根据结点删
void Erase(SLinkListNode **ppFirst, SLinkListNode *pPos)
{
	assert(*ppFirst);
	assert(pPos);

	if (pPos == *ppFirst){
		PopFront(ppFirst);
		return;
	}
	SLinkListNode *pCur;
	pCur = *ppFirst;
	while (pCur->pNext != pPos){
		pCur = pCur->pNext;
	}
	pCur->pNext = pPos->pNext;
	free(pPos);
}

//查找
SLinkListNode *Find(SLinkListNode *pFirst, DataType data)
{
	SLinkListNode *pNode;
	for (pNode = pFirst; pNode; pNode = pNode->pNext){
		if (pNode->date == data){
			return pNode;
		}
	}
	return NULL;
}

// 按值删除，只删遇到的第一个 
void SLinkListRemove(SLinkListNode **ppFirst, DataType data)
{
	assert(ppFirst);
	
	SLinkListNode *pNode = Find(*ppFirst, data);
	if (pNode){
		Erase(ppFirst, pNode);
	}
}

// 按值删除，删除所有的 
void SLinkListRemoveAll(SLinkListNode **ppFirst, DataType data)
{
	assert(ppFirst);

	SLinkListNode *pNode, *pNextNode;
	/*while (1){
		pNode = Find(*ppFirst, data);
		if (pNode){
			Erase(ppFirst, pNode);
		}
		else{
			break;
		}
	}*/
	pNode = *ppFirst;
	while (pNode->pNext){
		pNextNode = pNode->pNext;
		if (pNextNode->date == data){
			pNode->pNext = pNode->pNext->pNext;
			free(pNextNode);
		}
		else{
			pNode = pNode->pNext;
		}
	}
	if ((*ppFirst)->date == data){
		PopFront(ppFirst);
	}
}

void Print(SLinkListNode *pFirst)
{
	SLinkListNode *pNode;
	pNode = pFirst;
	while (pNode){
		printf("%d -> ",pNode->date);
		pNode = pNode->pNext;
	}
	printf("NULL\n");
}

int main()
{
	SLinkListNode *pFirst;
	SLinkListInit(&pFirst);

	SLinkListPushFront(&pFirst, 7);
	SLinkListPushFront(&pFirst, 6);
	SLinkListPushFront(&pFirst, 5);
	SLinkListPushFront(&pFirst, 6);
	Print(pFirst);

	/*SLinkListPushBack(&pFirst, 1);
	SLinkListPushBack(&pFirst, 2);
	SLinkListPushBack(&pFirst, 3);
	Print(pFirst);*/

	/*SLinkListRemove(&pFirst, 6);
	Print(pFirst);*/

	SLinkListRemoveAll(&pFirst, 6);
	Print(pFirst);
	
	//Print(Find(pFirst, 7));

	/*Erase(&pFirst, Find(pFirst, 6));
	Print(pFirst);*/

	/*PopBack(&pFirst);
	PopFront(&pFirst);
	Print(pFirst);*/

	system("pause");
	return 0;
}

运行结果：