无头单向非循环链表的实现

man.c文件

#include"SList.h"

int main()
{
	SListTest();
	system("pause");
	return 0;
}

SList.h文件

#pragma once

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

//无头单向非循环链表
typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType _data;
	struct SListNode *_next;
}SListNode;
typedef struct SList
{
	SListNode *_head;
}SList;

void SListInit(SList *plist);
void SListDestory(SList *plist);

void SListPushBack(SList *plist, SLTDataType x);
void SListPopBack(SList *plist);
void SListPushFront(SList *plist, SLTDataType x);
void SListPopFront(SList *plist);

SListNode* SListFind(SList *plist, SLTDataType x);
void SListInsertAfter(SListNode *pos, SLTDataType x);
void SListEraseAfter(SListNode *pos);
void SListRemove(SList *plist, SLTDataType x);

void SListPrint(SList *plist);
void SListTest();

SList.c文件

#include"SList.h"

void SListInit(SList *plist)
{
	assert(plist);

	plist->_head = NULL;
}

void SListDestory(SList *plist)
{
	assert(plist);

	SListNode *cur = plist->_head;
	while (cur)
	{
		SListNode *next = cur->_next;
		free(cur);
		cur = next;
	}
}

SListNode * BuySListNode(SLTDataType x)
{
	SListNode *newNode = malloc(sizeof(SListNode));
	newNode->_data = x;
	newNode->_next = NULL;
	return newNode;
}

void SListPushBack(SList *plist, SLTDataType x)
{
	assert(plist);

	if (plist->_head == NULL)
	{
		plist->_head = BuySListNode(x);
	}
	else
	{
		SListNode *tail = plist->_head;
		while (tail->_next)
		{
			tail = tail->_next;
		}
		tail->_next = BuySListNode(x);
	}
}

void SListPopBack(SList *plist)
{
	assert(plist);

	SListNode *tail = plist->_head;
	SListNode *prev=NULL;
	if (tail->_next == NULL)
	{
		free(tail);
		plist->_head = NULL;
	}
	else
	{
		while (tail->_next)
		{
			prev = tail;
			tail = tail->_next;
		}
		free(tail);
		prev->_next = NULL;
	}
}

void SListPushFront(SList *plist, SLTDataType x)
{
	assert(plist);

	SListNode *newNode = BuySListNode(x);
	newNode->_next = plist->_head;
	plist->_head = newNode;
}

void SListPopFront(SList *plist)
{
	assert(plist);

	SListNode *cur = plist->_head;
	plist->_head = plist->_head->_next;
	free(cur);
	cur = NULL;
}

SListNode* SListFind(SList *plist, SLTDataType x)
{
	assert(plist);

	SListNode *cur = plist->_head;
	while (cur)
	{
		if (cur->_data == x)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}

void SListInsertAfter(SListNode *pos, SLTDataType x)
{
	assert(pos);

	SListNode *newNode = BuySListNode(x);
	SListNode *next = pos->_next;
	pos->_next = newNode;
	newNode->_next = next;
}
void SListEraseAfter(SListNode *pos)
{
	assert(pos);

	SListNode *next = pos->_next;
	SListNode *nextNext = next->_next;
	pos->_next = nextNext;
	free(next);
	next = NULL;
}

void SListRemove(SList *plist, SLTDataType x)
{
	assert(plist);

	SListNode *prev = plist->_head;
	SListNode *cur = prev->_next;
	while (cur)
	{
		if (cur->_data == x)
		{
			prev->_next = cur->_next;
			free(cur);
			cur = prev->_next;
		}
		else
		{
			prev = cur;
			cur = cur->_next;
		}
	}
	if (plist->_head->_data== x)
		plist->_head = plist->_head->_next;
}

void SListPrint(SList *plist)
{
	assert(plist);

	SListNode *cur = plist->_head;
	while (cur)
	{
		printf("%d->", cur->_data);
		cur = cur->_next;
	}
	printf("NULL\n");
}

void SListTest()
{
	SList sl;
	SListInit(&sl);
	SListPushBack(&sl, 1);
	SListPushBack(&sl, 2);
	SListPushBack(&sl, 3);
	SListPushBack(&sl, 2);
	SListPrint(&sl);
	
	SListRemove(&sl, 2);

	SListPrint(&sl);

}