带头双向循环链表

//顺序表和链表（带头双向循环链表）的区别
// 
//顺序表的优点：支持下标随机访问、缓存利用率高
//顺序表的缺点：头部或中间插入、删除数据效率低；扩容（有一定程度性能消耗、可能存在一定程度的空间浪费）

//链表的优点：任意位置的插入、删除数据为：O(1)；按需申请、释放空间
//链表的缺点：不支持下标随机访问、缓存利用率低
//顺序表与链表相辅相成、相互弥补缺点

Test.c

#include "List.h"

void TestList1()
{
	LTNode* plist = ListInit();
	ListPushBack(plist,1);
	ListPushBack(plist,2);
	ListPushBack(plist,3);
	ListPushBack(plist,4);
	ListPushBack(plist,5);
	//第一次尾插打印
	ListPrint(plist);
	
	ListPushFront(plist, 1);
	ListPushFront(plist, 2);
	//第一次头插打印
	ListPrint(plist);

	ListPopBack(plist);
	ListPopBack(plist);
	//第一次尾删打印
	ListPrint(plist);
	
	ListPopFront(plist);
	ListPopFront(plist);
	ListPopFront(plist);
	ListPopFront(plist);
	
	//第一次头删打印
	ListPrint(plist);
}

int main()
{
	TestList1();
	return 0;
}

List.h

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

//数据类型的申明
typedef int LTDataType;

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

//函数（接口）的申明

//链表的初始化
LTNode* ListInit();

//打印
void ListPrint(LTNode* phead);

//尾插结点：x
void ListPushBack(LTNode* phead,LTDataType x);

//头插结点：x
void ListPushFront(LTNode* phead, LTDataType x);

//尾删
void ListPopBack(LTNode* phead);

//头删
void ListPopFront(LTNode* phead);

// 在pos位置之前插入x
void ListInsert(LTNode* pos, LTDataType x);

// 删除pos位置的结点
void ListErase(LTNode* phead,LTNode* pos);

//计算链表的长度
int ListSize(LTNode* phead);

//链表的销毁
void ListDestory(LTNode* phead);

List.c

#include "List.h"

static LTNode* BuyListNode(LTDataType x) //创建结点
{
	LTNode* node=(LTNode*)malloc(sizeof(LTNode));
	if (NULL==node)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

//链表的初始化
LTNode* ListInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

//打印
void ListPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next; // cur跳过哨兵位结点，从第二个节点开始
	while (cur!=phead)
	{
		printf("%d ",cur->data);
		cur = cur->next; //cur++
	}
	printf("\n");
}


//尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	//assert(phead);
	//LTNode* newnode = BuyListNode(x);
	//LTNode* tail = phead->prev;  //找尾结点
	////链接原尾结点与新结点
	//tail->next = newnode;
	//newnode->prev = tail;
	//newnode->next = phead;
	//phead->prev = newnode;

	assert(phead);
	ListInsert(phead, x);
}

//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	//assert(phead);
	//LTNode* newnode = BuyListNode(x);
	//LTNode* next = phead->next; //先保存插入之前的第二个结点（地址）

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

	assert(phead);
	ListInsert(phead->next,x);
}

//尾删
void ListPopBack(LTNode* phead)
{
	//assert(phead);
	////找到尾结点和倒数第二个结点
	//LTNode* tail = phead->prev;
	//LTNode* tailprev = tail->prev;
	//
	//free(tail);
	//assert(tail!= phead); //断言：当尾删到链表为空时，报错

	//// tailprev 与 phead的链接
	//tailprev->next = phead;
	//phead->prev = tailprev;

	assert(phead);
	ListErase(phead,phead->prev);
	
}

//头删
void ListPopFront(LTNode* phead)
{
	//assert(phead);
	////保存第二个、第三个结点
	//LTNode* next1 = phead->next;
	//LTNode* next2 = next1->next;

	////头删加断言
	//free(next1);
	//assert(next1!=phead);

	////链接phead与next2
	//phead->next = next2;
	//next2->prev = phead;

	assert(phead);
	ListErase(phead,phead->next);
	
}

// 在pos位置之前插入x
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);

	//保存pos的前一个结点
	LTNode* prev = pos->prev;
	//链接 prev  newnode和pos
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

// 删除pos位置的结点
void ListErase(LTNode* phead,LTNode* pos)
{
	assert(pos);
	assert(pos!=phead);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	free(pos);
	
	prev->next = next;
	next->prev = prev;
}

//计算链表的长度
int ListSize(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	int size = 0;
	while (cur!=phead)
	{
		size++;
		cur = cur->next; //cur++
	}
	return size;
}

//链表的销毁
void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;

	//遍历链表，再逐个销毁
	while (cur != phead)
	{
		LTNode* next = cur->next;
		ListErase(phead,cur);
		cur = next;
	}
	//销毁哨兵位的头结点
	free(phead);
	phead = NULL;
}