C语言数据结构——单链表

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef int SLNDataType;

typedef struct SLNode {
	SLNDataType data;
	struct SLNode* next;
}SLN;

//建链
SLN* CreateSLN(int n);

//创建节点
SLN* BuySLN(SLNDataType x);

//打印
void SLNPrint(SLN* phead);

//错误尾插
void SLNPushBackerr(SLN* phead, SLNDataType x);
//尾插
void SLNPushBack(SLN** pphead, SLNDataType x);

//错误尾删
void SLNPopBackerr(SLN* phead);
//尾删
void SLNPopBack(SLN** pphead);

//头插
void SLNPushFront(SLN** pphead,SLNDataType x);

//头删
void SLNPopFront(SLN** pphead);

//查找一个数，返回这个数所在的节点
SLN* SLNFind(SLN* phead, SLNDataType x);

//在pos位置之后插入
void SLNInsertAfter(SLN* pos, SLNDataType x);

//在pos位置之前插入
void SLNInsertBefore(SLN** pphead, SLN* pos, SLNDataType x);

//删除pos位置之后的
void SLNEraseAfter(SLN* pos);

//删除pos
void SLNErase(SLN** pphead, SLN* pos);

//销毁
void SLNDestroy(SLN** pphead);


//动态申请一个节点
SLN* BuySLN(SLNDataType x) {
	SLN* newnode = (SLN*)malloc(sizeof(SLN));
	if (newnode == NULL) {
		perror("BuySLN is fail!\n");
		exit(-1);
	}
	else {
		newnode->data = x;
		newnode->next = NULL;
	}

	return newnode;
}

//创建单链表
SLN* CreateSLN(int n) {
	SLN* phead = NULL, * ptail = NULL;
	for (int i = 0; i < n; i++) {
		//int x = 0;
		//scanf("%d", &x);
		//SLN* newnode = BuySLN(x);
		SLN* newnode = BuySLN(i);
		if (phead == NULL) {
			phead = ptail = newnode;
		}
		else {
			ptail->next = newnode;
			ptail = newnode;
		}
	}
	
	return phead; 
}

void SLNPrint(SLN* phead) {
	SLN* cur = phead;
	while (cur) {
		printf("[%d|%p] -> ", cur->data, cur->next);
		cur = cur->next;
	}
	printf("NULL\n");
}

void SLNPushBack(SLN**  pphead, SLNDataType x) {
	//创建节点，放入数据
	SLN* newnode = BuySLN(x);

	//当plist=NULL，把新节点链接到plist
	if (*pphead == NULL) {
		*pphead = newnode;
	}
	else {
		SLN* tail = *pphead;
		//找到尾节点
		while (tail->next) {
			tail = tail->next;
		}
		//链接
		tail->next = newnode;
	}
}

void SLNPopBack(SLN** pphead) {
	assert(*pphead);

	if ((*pphead)->next == NULL) {
		//*pphead = &plist，free释放plist的内存
		free(*pphead);
		*pphead = NULL;
	}
	else {
		//SLN* prev = *pphead;
		//SLN* tail = prev->next;
		//while (tail->next) {
		//	tail = tail->next;
		//	prev = prev->next;

		//}
		//free(tail);
		//prev->next = NULL;

		SLN* tail = *pphead;
		while (tail->next->next) {
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

void SLNPushFront(SLN** pphead, SLNDataType x) {
		SLN* newnode = BuySLN(x);
		newnode->next = *pphead;
		*pphead = newnode;
}

void SLNPopFront(SLN** pphead) {
	assert(*pphead);
	//标记pphead
	SLN* prev = *pphead;
	//pphead后移
	*pphead = (*pphead)->next;
	//释放原来的pphead所指向的内存
	free(prev);
}

SLN* SLNFind(SLN* phead, SLNDataType x) {
	SLN* cur = phead;
	while (cur) {
		if (cur->data == x) {
			return cur;
		}
		else {
			cur = cur->next;
		}
	}
	return NULL;
}

void SLNInsertAfter(SLN* pos, SLNDataType x) {
	assert(pos);
	//创建新节点
	SLN* newnode = BuySLN(x);
	newnode->next = pos->next;
	pos->next = newnode;

}

void SLNInsertBefore(SLN** pphead, SLN* pos, SLNDataType x) {
	assert(pos);
	//当pos为头节点
	if (pos == *pphead) {
		//SLN* newnode = BuySLN(x);
		//newnode->next = *pphead;
		//*pphead = newnode;
		SLNPushFront(pphead, x);
	}
	else {
		SLN* prev = *pphead;
		while (prev->next != pos) {
			prev = prev->next;
		}
		SLN* newnode = BuySLN(x);
		newnode->next = prev->next;
		prev->next = newnode;
	}
}

void SLNEraseAfter(SLN* pos) {
	assert(pos);
	if (pos->next == NULL) {
		return;
	}
	else {
		SLN* erasenode = pos->next;
		pos->next = pos->next->next;
		free(erasenode);
	}
}

void SLNErase(SLN** pphead, SLN* pos) {
	assert(pos);
	if (pos == *pphead) {
		SLNPopFront(pphead);
	}
	else {
		SLN* prev = *pphead;
		while (prev->next != pos) {
			prev = prev->next;
		}
		prev->next = prev->next->next;
		free(pos);
	}
}

void SLNDestroy(SLN** pphead) {
	SLN* cur = *pphead;
	while (cur) {
		SLN* erasenode = cur;
		cur = cur->next;
		free(erasenode);
	}
	*pphead = NULL;
}