初级数据结构 — 带头双向循环链表

目录

1. 什么是带头双向链表

2. 链表代码

2.1 dlink.h 函数声明

2.2 dlink.c 函数功能实现

2.3 dlink.c 函数功能测试

3. 部分函数功能图片解析

3.1 pos位置前插入

3.1 pos位置删除

---

1. 什么是带头双向链表

        带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单。

• 带头：即具有头节点，它不存储数据。对链表进行插入删除操作时也不会影响该节点。
• 双向：即链表的有两个指针，一个指向前一个结点，一个指向后一个结点。 
• 循环：链表的头结点存储了尾结点的地址，链表的尾结点存储了头节点的地址

2. 链表代码

2.1 dlink.h 函数声明

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#include<stdbool.h>


typedef int LTDataType;


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

}LTNode;


void ListPrint(LTNode* phead);
LTNode* ListInit();

void ListPushBack(LTNode* phead, LTDataType x);
void ListPushFront(LTNode* phead, LTDataType x);

void ListPopBack(LTNode* phead);
void ListPopFront(LTNode* phead);


// 双向链表在pos的前面进行插入
void ListInsert(LTNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(LTNode* pos);


void ListPopFront_Era(LTNode* phead);//函数复用版本
void ListPopBack_Era(LTNode* phead);//函数复用版本
void ListPushBack_Ins(LTNode* phead, LTDataType x);//函数复用版本
void ListPushFront_Ins(LTNode* phead, LTDataType x);//函数复用版本

void ListDestory(LTNode* phead);//链表的销毁 
int ListSize(LTNode* phead);//链表的长度
bool ListEmpty(LTNode* phead);//链表的是否为空链表

---

2.2 dlink.c 函数功能实现

#define _CRT_SECURE_NO_WARNINGS 1
#include"dlink.h"
#include<errno.h>

//链表的打印
void ListPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	printf("phead-->");
	while (cur != phead)
	{
		printf("%d-->", cur->data);
		cur = cur->next;
	}
	printf("phead");
}

//链表的初始化 创建头部结点
LTNode* ListInit()
{
	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));
	assert(phead);
	phead->prev = phead;
	phead->next = phead; 

	return phead;
	
}

//创建新节点
LTNode* BuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (NULL  == newnode)
	{
		perror("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->prev = NULL;
	newnode->next = NULL; 

	return newnode;
}

//链表的尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = BuyNode(x);

	LTNode* tail = phead->prev;

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

}

//链表的头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = BuyNode(x);

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


//链表的尾删
void ListPopBack(LTNode* phead)
{
	assert(phead);//断言空指针
	assert(phead->next != phead);//断言删空

	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;
	free(tail);

	tailPrev->next = phead;
	phead->prev = tailPrev;
}


//链表的头删
void ListPopFront(LTNode* phead)
{
	assert(phead);//断言空指针
	assert(phead->next != phead);//断言删空

	LTNode* nhead = phead->next->next;

	free(phead->next);

	phead->next = nhead;
	nhead->prev = phead;

}


// 双向链表查找
LTNode* ListFind(LTNode* phead, LTDataType x)
{
	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* newnode = BuyNode(x);
	
	LTNode* ppos = pos->prev;

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

}

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

	LTNode* pos_next= pos->next;
	LTNode* pos_prev = pos->prev;
	
	pos_prev->next = pos_next;
	pos_next->prev = pos_prev;
	free(pos);
	
	
}

//链表头删 函数复用
void ListPopFront_Era(LTNode* phead)
{
	assert(phead);//断言空指针
	assert(phead->next != phead);//断言删空

	ListErase(phead->next);//函数复用

}

//链表尾删 函数复用
void ListPopBack_Era(LTNode* phead)
{
	assert(phead);//断言空指针
	assert(phead->next != phead);//断言删空

	ListErase(phead->prev);//函数复用
}

//链表尾插，函数复用
void ListPushBack_Ins(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead, x);//函数复用

}


//链表头插 函数复用
void ListPushFront_Ins(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead->next, x);//函数复用
}


//销毁整个链表
void ListDestory(LTNode* phead)
{
	assert(phead);

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

	}
	free(phead);
	phead = NULL;
}

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

//链表的是否为空链表
bool ListEmpty(LTNode* phead)
{
	assert(phead);

	return phead == phead->next;
}

---

2.3 dlink.c 函数功能测试

#define _CRT_SECURE_NO_WARNINGS 1
#include"dlink.h"


void test1()
{
	LTNode* plist = ListInit();

	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPushBack(plist, 6);
	ListPushFront(plist, 0);
	

	LTNode* cur = ListFind(plist, 5);
	
	ListInsert(cur, 55);
	ListInsert(cur, 66);
	ListErase(cur);
	ListErase(cur);
	ListPrint(plist);
}



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

---

3. 部分函数功能图片解析

3.1 pos位置前插入

---

3.1 pos位置删除