C实现带头双链表

目录

一.结构

二.test.c文件

二.List.c

三.List.h

---

一.结构

a.链表的三种类型，双向/单向

b.带哨兵位头/不带哨兵位头

c.循环/非循环

         这3类特征之间可以随意组合，组合出多达8种链表。之前我们学着写过单向不带头非循环链表，它的结构简单，不足之处较多，我们了解它是为了给学习哈希桶、图的邻接表打下基础。

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

     个人理解，在带头双向链表中，每个节点都有三个结构体类型的地地址用来管理连接，抽象来说，节点外面有一个结构体地址来指向结构体，结构体里面又有两个结构体地址，这样通过这些结构体地址，可以轻松的实现循环。具体代码如下：

二.test.c文件

实现了增删查改的功能。

void ListTest3()
{
	ListNode* phead = InitList();
	ListPushBack(phead, 1);
	ListPushBack(phead, 2);
	ListPushBack(phead, 3);
	ListPushBack(phead, 4);

	Listprint(phead);

	ListPopBack(phead);
	ListPopBack(phead);
	ListPopBack(phead);

	Listprint(phead);

	ListPushFront(phead,10);
	ListPushFront(phead, 11);
	ListPushFront(phead, 12);
	Listprint(phead);

	ListPopFront(phead);

	ListNode* pos = ListFind(phead, 10);
	ListInsert(pos, 2);
	ListDestroy(phead);
}
int main()
{
	//1.顺序表测试
	//SlistTest1();
	//2.单链表测试
	//SlistTest2();
	//3.双链表测试
	ListTest3();
	return 0;
}

二.List.c

#include"List.h"

ListNode* BuyListNode(DataType x)
{
	ListNode* tmp = (ListNode*)malloc(sizeof(ListNode));
	if (tmp == NULL)
	{
		printf("空间申请失败\n");
		exit(-1);
	}
	else {
		tmp->data = x;
		tmp->next = NULL;
		tmp->prev = NULL;
		return tmp;
	}


}



ListNode* InitList()
{
	ListNode*phead=BuyListNode(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}


void ListPushBack(ListNode* phead, DataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	phead->prev->next = newnode;
	newnode->prev = phead->prev;

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

void Listprint(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

void ListDestroy(ListNode* phead)
{
	assert(phead);
	ListNode* cur=phead->next;
	while (cur != phead)
	{
		ListNode* next1 = cur->next;
		free(cur);
		cur =next1;
	}
	phead->next = phead;
	phead->prev = phead;
}


void ListPopBack(ListNode* phead)
{
	assert(phead);
	if (phead->next != phead)
	{
		ListNode* tail = phead->prev;
		ListNode* tailprev = tail->prev;
		free(tail);
		tail = NULL;
		tailprev->next = phead;
		phead->prev = tailprev;
	}
	

}

void ListPushFront(ListNode* phead,DataType x)
{
	ListNode* newnode = BuyListNode(x);
	assert(phead);
	//只有头结点
	ListNode* First = phead->next;

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

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

void ListErase(ListNode* pos)
{
	assert(pos);//phead不能删，如果是find出来的pos，pos不可能为phead
	ListNode* prev = pos->prev;
	ListNode* next = pos->next;

	free(pos);
	pos = NULL;

	prev->next = next;
	next->prev = prev;
}
void ListPopFront(ListNode* phead)
{
	assert(phead);
	if (phead->next != phead)
	{
		ListErase(phead->next);
	}
}


//查找
ListNode* ListFind(ListNode* phead, DataType x)
{
	assert(phead);

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


void ListInsert(ListNode* pos, DataType x)
{
	assert(pos);
	ListNode* newnode = BuyListNode(x);
	ListNode* posprev = pos->prev;

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

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

三.List.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//带头双链表用三个结构体地址管理
typedef int DataType;
typedef struct ListNode {
	DataType data;
	struct ListNode* prev;
	struct ListNode* next;
}ListNode;


ListNode* BuyListNode(DataType x);
ListNode* InitList();
void ListPushBack(ListNode*phead, DataType x);
void Listprint(ListNode* phead);
void ListDestroy(ListNode*phead);
void ListPopBack(ListNode* phead);
void ListPushFront(ListNode*phead,DataType x);
void ListPopFront(ListNode* phead);
void ListErase(ListNode* pos);
ListNode* ListFind(ListNode* phead, DataType x);
void ListInsert(ListNode*pos, DataType x);