带头循环双链表的增删查改

头文件

#pragma once

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

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


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

函数部分

#include "list.h"

//申请一个新节点
LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

// 创建返回链表的头结点.
LTNode* ListCreate()
{
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

// 双向链表销毁
void ListDestory(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}

	free(phead);
}

// 双向链表打印
void ListPrint(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	printf("guard<=>");//哨兵位

	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

// 双向链表查找
LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

// 双向链表在pos的前面进行插入
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* newnode = BuyLTNode(x);

	prev->next = newnode;
	newnode->prev = prev;

	newnode->next = pos;
	pos->prev = newnode;
}

// 双向链表尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	ListInsert(phead, x);//套用“pos前插入”函数

	//不套用“pos前插入”函数
	//assert(phead);

	//LTNode* newnode = BuyLTNode(x);
	//LTNode* tail = phead->prev;//原来的尾

	//tail->next = newnode;
	//newnode->prev = tail;

	//newnode->next = phead;
	//phead->prev = newnode;
}

// 双向链表头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	ListInsert(phead->next, x);//套用“pos前插入”函数

	//不套用“pos前插入”函数
	//assert(phead);

	//LTNode* newnode = BuyLTNode(x);
	//LTNode* first = phead->next;//原来的头

	//phead->next = newnode;
	//newnode->prev = phead;
	
	//newnode->next = first;
	//first->prev = newnode;		
}

// 双向链表删除pos位置的节点
void ListErase(LTNode* pos)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* next = pos->next;

	prev->next = next;
	next->prev = prev;
	free(pos);
}

bool LTEmpty(LTNode* phead)
{
	assert(phead);

	return phead->next == phead;
}

// 双向链表尾删
void ListPopBack(LTNode* phead)
{
	//套用删除“pos处节点”函数
	assert(phead);
	assert(!LTEmpty(phead));

	ListErase(phead);

	//不套用删除“pos处节点”函数
	//LTNode* tail = phead->prev;//原来的尾
	//LTNode* tailprev = tail->prev;
	
	//free(tail);
	//tailprev->next = phead;
	//phead->prev = tailprev;
}

// 双向链表头删
void ListPopFront(LTNode* phead)
{
	//套用删除“pos处节点”函数
	assert(phead);
	assert(!LTEmpty(phead));

	ListErase(phead->next);

	//不套用删除“pos处节点”函数
	//LTNode* first = phead->next;//原来的尾
	//LTNode* firstnext = first->next;

	//free(first);
	//phead->next = firstnext;
	//firstnext->prev = phead;
}

测试部分

#include "list.h"

void TestList1()
{
	LTNode* plist = ListCreate();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPrint(plist);

	LTNode* pos = ListFind(plist, 2);
	if (pos)
	{
		ListInsert(pos, 15);
	}
	ListPrint(plist);

	ListDestory(plist);
	plist = NULL;
}

int main()
{
	TestList1();

	return 0;
}