【数据结构】双向带头循环链表实现及总结

简单不先于复杂，而是在复杂之后。

1. 双向带头循环链表的实现

List.h

#pragma once
#include 
#include 
#include 
#include 

typedef int LTDataType;

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

//初始化
LTNode* ListInit();

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

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

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

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

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

//链表判空
bool ListEmpty(LTNode* phead);

//链表长度
size_t ListSize(LTNode* phead);

//遍历查找(也可以充当修改的功能，所以链表不需要单独实现修改的功能)
LTNode* ListFind(LTNode* phead, LTDataType x);

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

//删除pos位置
void ListErase(LTNode* pos);

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

List.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"


LTNode* ListInit()
{
	LTNode* guard = (LTNode*)malloc(sizeof(LTNode));
	if (guard == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	guard->next = guard;
	guard->prev = guard;

	return guard;
}

LTNode* BuyListNode(LTDataType x)
{
	LTNode* Node = (LTNode*)malloc(sizeof(LTNode));
	if (Node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	Node->next = NULL;
	Node->prev = NULL;
	Node->data = x;

	return Node;

}

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


void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	/*LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;

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

	ListInsert(phead, x);
	//双向带头循环链表不需要专门写头插尾插
	//只需要复用ListInsert的代码即可
}

void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	//LTNode* newnode = BuyListNode(x);
	//
	先链接newnode和phead->next节点之间的关系
	//newnode->next = phead->next;
	//phead->next->prev = newnode;
	//phead->next = newnode;
	//newnode->prev = phead;

	//如果不想关心顺序
	LTNode* first = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;

	ListInsert(phead->next, x);
}


void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

	/*LTNode* tail = phead->prev;
	LTNode* prev = tail->prev;

	prev->next = phead;
	phead->prev = prev;
	free(tail);
	tail = NULL;*/

	ListErase(phead->prev);
}

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

	/*LTNode* first = phead->next;
	LTNode* second = first->next;

	phead->next = second;
	second->prev = phead;

	free(first);
	first = NULL;*/

	ListErase(phead->next);
}

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

	return phead->next == phead;
}

size_t ListSize(LTNode* phead)
{
	assert(phead);

	size_t n = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		++n;
		cur = cur->next;
	}

	return n;
}


LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);

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

void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

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

	//prev newnode pos 链接
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}


void ListErase(LTNode* pos)
{
	assert(pos);

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

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


//可以传二级指针，内部置空头结点
//建议：也可以考虑一级指针，让调用 ListDestory 的人置空（可以保持接口一致性）
void ListDestory(LTNode* phead)
{
	assert(phead);

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

	free(phead);
	//phead = NULL;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"

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

	ListPrint(plist);


	ListPushFront(plist, 10);
	ListPushFront(plist, 20);
	ListPushFront(plist, 30);
	ListPushFront(plist, 40);
	ListPrint(plist);


	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPrint(plist);

}

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

	ListPopFront(plist);
	ListPopFront(plist);
	ListPrint(plist);

	ListPopFront(plist);
	ListPopFront(plist);
	ListPrint(plist);

}

int main()
{
	TestList2();

	return 0;
}

2. 顺序表和链表的区别

不同点	顺序表	链表
存储空间	物理上一定连续	逻辑上连续，但物理上不一定连续
随机访问	支持 O(1)	不支持 O(N)
任意位置插入或删除元素	可能需要搬移元素，效率低 O(N)	只需修改指针指向
插入	动态顺序表，空间不够时需要扩容	没有容量的概念
应用场景	元素高效存储+频繁访问	任意位置插入和删除频繁
缓存利用率	高	低

备注：缓存利用率参考存储体系结构以及局部原理性。

顺序表优点：

1. 尾插尾删效率很高。
2. 随机访问。（用下标访问）’
3. 相比链表结构：cpu高速缓存命中率更高。

​

顺序表缺点：

1. 头部和中部插入删除效率低。 —O(N)
2. 扩容。 性能消耗+空间浪费

链表优点：

1. 任意位置插入删除效率很高。 O(1)
2. 按需申请释放。

链表缺点：

1. 不支持随机访问

cpu执行指令，不会直接访问内存。

1. 先看数据在不在三级缓存，在（命中）。直接访问
2. 不在（不命中），先加载到缓存，再访问。当要访问一个数据时，不会只访问这个数据的几个字节，而是从这个位置开始的一段都加载进去缓存。（加载多少取决于硬件）

与程序员相关CPU缓存知识