双链表的增删改查（c语言）

链表的分类

1：单向或双向

2：带头或不带头

3： 循环或非循环

此上所属种类便可组成八种不同的链表，但其实最常用的链表也就两种：

1：无头单项非循环链表

结构简单，不会单独用来存储数据，更偏向于作为其他数据结构的子结构。

2：带头双向循环链表

 结构复杂，一般用来单独存储数据，一般实际使用的链表都是双向带头循环链表。

 双向带头链表的实现：

双向循环链表的节点由三部分组成：

 节点的创建：

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

带头结点的双向循环链表的基础操作：

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

具体实现

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

//申请节点
ListNode* BuyNode(LTDataType x){
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (!newnode){
		assert(0);
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}
// 创建返回链表的头结点.
ListNode* ListCreate(){
	ListNode* head = BuyNode(0);
	head->next = head;
	head->prev = head;
	return head;
}
// 双向链表销毁
void ListDestory(ListNode** pHead){
	ListNode* cur = (*pHead)->next;
	while (cur != *pHead){
		(*pHead)->next = cur->next;
		free(cur);
		cur = (*pHead)->next;
	}
	free(*pHead);
	*pHead = NULL;
}
//双向链表判空
bool ListEmpty(ListNode* pHead){
	assert(pHead);
	return pHead->next == pHead;
}
// 双向链表打印
void ListPrint(ListNode* pHead){
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead){
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x){
	ListNode* cur = pHead;
	ListNode* newnode = BuyNode(x);
	newnode->prev = cur->prev;
	newnode->next = cur;
	newnode->prev->next = newnode;
}
// 双向链表尾删
void ListPopBack(ListNode* pHead){
	ListNode* cur = pHead;
	if (ListEmpty(pHead)){
		return;
	}
	ListNode* tmp = cur->prev;
	cur->prev->prev->next = cur;
	cur->prev = cur->prev->prev;
	free(tmp);
}
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x){
	ListNode* cur = pHead;
	ListNode* newnode = BuyNode(x);
	newnode->next = cur->next;
	newnode->prev = cur;
	cur->next = newnode;
	newnode->next->prev = newnode;
}
// 双向链表头删
void ListPopFront(ListNode* pHead){
	if (ListEmpty(pHead)){
		return;
	}
	ListNode* delnode = NULL;
	delnode = pHead->next;
	delnode->next->prev = pHead;
	pHead->next = delnode->next;
	free(delnode);
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x){
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead){
		if (cur->data == x){
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x){
	if (!pos){
		return;
	}
	ListNode* newnode = BuyNode(x);
	newnode->prev = pos->prev;
	newnode->next = pos;
	pos->prev->next = newnode;
	pos->prev = newnode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos){
	if (!pos){
		return;
	}
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
}