顺序表和链表

夢に向かって進む

于 2023-04-14 22:54:47 发布

阅读量109

点赞数

分类专栏：数据结构初阶文章标签：链表数据结构 c语言

本文链接：https://blog.youkuaiyun.com/qq_66483104/article/details/130163395

版权

数据结构初阶专栏收录该内容

6 篇文章

订阅专栏

本文详细介绍了线性表的概念，包括顺序表和链表两种常见实现方式。顺序表使用数组存储，支持快速随机访问，但插入删除操作效率较低。链表则允许非连续存储，插入删除操作更灵活，但访问速度较慢。文章提供了动态顺序表的C语言实现，并探讨了其优缺点。同时，介绍了链表的分类，如单向链表、双向链表和带头双向循环链表，以及它们的适用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

3.4带头双向循环链表的实现，也叫带哨兵位双向循环链表

4.顺序表和链表的区别

1.线性表

线性表(linear list)是n个具有相同特性的数据元素的

有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表有：顺序表、链表、队列、字符串...

线性表在逻辑结构上是线性结构，也就是说是连续的一条直线。但是在物理结构上并不是一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

2.顺序表

2.1概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表一般可以分为：

1.静态顺序表：使用定长数组储存元素。

2.动态顺序表：使用动态开辟的数组存储

2.2接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空
间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间
大小，所以下面是我们要实现动态顺序表的接口。

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

#define INIT_CAPACITY 3

typedef int SLDateType;

typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

//初始化和销毁
void SeqListInit(SeqList* ps);
void SeqListDestroy(SeqList* ps);

//扩容
void SeqListCheckCapacity(SeqList* ps);

//输出
void SeqListPrint(SeqList* ps);

//尾删、尾插
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPopBack(SeqList* ps);

//头删、头插
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);

//查找
int SeqListFind(SeqList* ps, SLDateType x);

//在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);

//删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

初始化和销毁

初始化

销毁

扩容

尾插接口实现

尾删接口实现

头插接口实现

如果头插N个数据时间复杂度是多少？时间复杂度是O(N^2)，每插入一个数据就要挪动一次数据，插入N个数据就要挪动N次数据是一个等差数列。

头删接口实现

如果头删，删除N个数据时间复杂度也是O(N^2).

查找接口实现

在pos位置插入

当我们有了这个Insert函数时可以复用在头插和尾插的接口上，它可以完成头插和尾插的任务

删除pos位置的值

同时Erase函数也可以复用在头删和尾删的接口上。

完整代码：

main.c

#include "SeqList.h"

void SeqL()
{
	SeqList s;
	int n = 0;
	SeqListInit(&s);

	SeqListInsert(&s, 0, 8);
	SeqListPrint(&s);

	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPrint(&s);

	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPrint(&s);

	SeqListPushFront(&s, 7);
	SeqListPushFront(&s, 6);
	SeqListPushFront(&s, 5);
	SeqListPrint(&s);

	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPrint(&s);

	printf("请输入要查找的数:");
	scanf("%d", &n);
	int ret = SeqListFind(&s, n);
	if (ret == -1)
	{
		printf("要查找的数据不存在!\n");
	}
	else
	{
		printf("找到了，下标是%d\n", ret);
	}

	//在指定范围下标位置插入
	SeqListInsert(&s, ret, 8);
	SeqListPrint(&s);

	//在指定范围下标位置删除
	SeqListErase(&s, ret);
	SeqListPrint(&s);

	SeqListDestroy(&s);
}

int main()
{
	SeqL();

	return 0;
}

SeqList.c

#include "SeqList.h"

void SeqListInit(SeqList* ps)
{
	assert(ps);

	ps->a = (SLDateType*)malloc(sizeof(SLDateType) * INIT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->size = 0;
	ps->capacity = INIT_CAPACITY;
}


void SeqListDestroy(SeqList* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}


void SeqListPrint(SeqList* ps)
{
	assert(ps);

	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void SeqListCheckCapacity(SeqList* ps)//扩容
{
	//当有效数据个数等于空间大小时需要进行增容
	if (ps->size == ps->capacity)
	{
		SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		else
		{
			ps->a = tmp;
			ps->capacity = ps->capacity * 2;
		}
	}
}


void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);

	ps->a[ps->size++] = x;
}

void SeqListPopBack(SeqList* ps)
{
	assert(ps->size > 0);

	ps->size--;
}


void SeqListPushFront(SeqList* ps, SLDateType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->size;
	while (end > 0)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}

	ps->a[end] = x;
	ps->size++;
}

void SeqListPopFront(SeqList* ps)
{
	assert(ps->size > 0);

	int head = 0;
	while (head < ps->size)
	{
		ps->a[head] = ps->a[head + 1];
		head++;
	}
	ps->size--;
}


int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}


void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos <= ps->size);
	SeqListCheckCapacity(ps);

	int trail = ps->size;
	while (trail > pos)
	{
		ps->a[trail] = ps->a[trail - 1];
		trail--;
	}

	ps->a[trail] = x;
	ps->size++;
}


void SeqListErase(SeqList* ps, int pos)
{
	assert(ps && ps->size > 0);

	int tmp = pos;
	while (tmp < ps->size - 1)
	{
		ps->a[tmp] = ps->a[tmp + 1];
		tmp++;
	}
	ps->size--;
}

SeqList.h

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

#define INIT_CAPACITY 3

typedef int SLDateType;

typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

//初始化和销毁
void SeqListInit(SeqList* ps);
void SeqListDestroy(SeqList* ps);

//扩容
void SeqListCheckCapacity(SeqList* ps);

//输出
void SeqListPrint(SeqList* ps);

//尾删、尾插
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPopBack(SeqList* ps);

//头删、头插
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);

//查找
int SeqListFind(SeqList* ps, SLDateType x);

//在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);

//删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

2.3顺序表的缺点

1. 中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

3.链表

3.1链表的概念及结构

概念：链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

数据结构中：

注：

1.从上图可看出，链式结构在逻辑上是连续的，但是在物理上比一定连续

2.实现中链表的节点一般都是从堆上申请出来的。

3.从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续。

3.2链表的分类

实际中的链表结构非常多样，以下情况组合起来就有八种链表结构：

1.单向或者双向

2.带头或者不带头

3.循环或者非循环

4.无头单向非循环单链表和带头双向循环链表

1.无头单向非循环链表：结构简单，一般不会单独用来存储数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

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

注：带头链表一般不使用结构体指针本身自己来指向头结点，使用的是结构体指针的成员next指针来指向头结点。

3.3链表的实现

//1、无头+单向+非循环链表增删查改实现
typedef int SLTDateType;

typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

//动态申请一个节点
SListNode* BuySListNode(SLTDateType x);

//打印单链表
void SListPrint(SListNode* plist);

//单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);

//单链表头插
void SListPushFront(SListNode** pplist, SLTDateType x);

//单链表尾删
void SListPopBack(SListNode** pplist);

//单链表头删
void SListPopFront(SListNode** pplist);

//单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);

//在单链表pos位置之后插入
//分析思考为什么不在pos位置之前插入？
//当在头节点进行插入时不就是头插吗？而且写起来比较烦琐，只需要调用头插即可
void SListInserAfter(SListNode* pos, SLTDateType x);

//单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos);
//单链表不适合在之前插入和当前位置删除，因为我们需要遍历找到前一个结点的位置时间复杂度为O(n)

//单链表的销毁
void SListDestroy(SListNode* plist);

问题：为什么使用二级指针来进行增删？为什么增删查改不写改？

1.增删如果使用一级指针我们就需要增加返回值来重新指定头节点写起来会更加的烦琐。

2.不写改的原因是查可以直接代替改，因为我们查找到了该节点并返回了该节点的地址可以直接使用该地址进行修改。

单链表尾插接口

忘了写断言：assert(pplist);

单链表头插接口

忘了写断言：assert(pplist);

单链表尾删接口

单链表头删接口

单链表查找接口

单链表在pos之后插入

单链表删除pos之后的结点

指针是用来保存地址的，而地址的类型是SListNode*，那么它本身类型就是SListNode类型，指针通过解引用就能使用它所指向的地址。

单链表销毁

完整代码：

main.c

#include "SList.h"

void test()
{
	SListNode* plist = NULL;
	//尾插
	SListPushBack(&plist, 5);
	SListPushBack(&plist, 6);
	//头插
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPrint(plist);



	SListPushFront(&plist, 7);
	SListPushFront(&plist, 8);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);
	

	SListNode* ret = SListFind(plist, 8);
	SListInserAfter(ret, 1);
	SListPrint(ret);
	SListEraseAfter(ret);
	SListPrint(ret);


	SListPopBack(&plist);
	SListPopFront(&plist);
	SListPopBack(&plist);
	SListPopFront(&plist);
	SListPrint(plist);

	
	SListDestroy(plist);
	plist = NULL;
}

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

SList.c

#include "SList.h"

//动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");//fail: 失败
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//打印单链表
void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;

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

//单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);
	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		SListNode* cur = *pplist;
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		
		cur->next = newnode;
	}
}

//单链表头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);
	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		newnode->next = *pplist;
		*pplist = newnode;
	}
}

//单链表尾删
void SListPopBack(SListNode** pplist)
{
	assert(*pplist && pplist);
	
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SListNode* tail = *pplist;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}

//单链表头删
void SListPopFront(SListNode** pplist)
{
	assert(*pplist && pplist);

	SListNode* next = (*pplist)->next;//保存下一个节点
	free(*pplist);
	*pplist = next;
}

//单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{

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

	return NULL;
}

//在单链表pos位置之后插入
//为什么不在pos位置之前插入？
void SListInserAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);

	SListNode* newnode = BuySListNode(x);

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

//单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos)
{
	assert(pos);

	SListNode* tmp = pos->next->next;
	free(pos->next);
	pos->next = tmp;
}

//单链表的销毁
//可以使用一级指针也可以使用二级指针来销毁链表
//一级指针是把指向的地址(保存的地址)以传值的形式传过来进行销毁。
//二级指针是把一级指针以传址的形式，传过来进行内部解引用置空的形式来销毁。
void SListDestroy(SListNode* plist)
{
	//可以使用一级指针销毁链表也可以使用二级指针销毁链表
	while (plist)
	{
		SListNode* next = plist->next;//保存下一个节点
		free(plist);
		plist = next;
	}
}

SList.h

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

typedef int SLTDateType;

typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

//动态申请一个节点
SListNode* BuySListNode(SLTDateType x);

//打印单链表
void SListPrint(SListNode* plist);

//单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);

//单链表头插
void SListPushFront(SListNode** pplist, SLTDateType x);

//单链表尾删
void SListPopBack(SListNode** pplist);

//单链表头删
void SListPopFront(SListNode** pplist);

//单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);

//在单链表pos位置之后插入
// 分析思考为什么不在pos位置之前插入？
void SListInserAfter(SListNode* pos, SLTDateType x);

//单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos);

//单链表的销毁
void SListDestroy(SListNode* plist);

快速搭建链表

当我们每次在刷链表相关的题目时如果出错了又想进行调试，如果直接在网页进行调试又不方便，复制下来题目又要把整个链表给完善非常的消耗时间，可以使用技巧快速构建一个简单链表。

方法1：要几个结点我们就定义几个指针，每个指针使用malloc来开辟一个空间进行赋值，让后使用指针所保存的地址把每一个成员的next指向另一块空间的地址，最后一个指向空。

方法2：有点绕自行理解。

//该题出自于LeetCode：移除链表元素
#include <stdio.h>
#include <stdlib.h>

struct ListNode 
{
    int val;
    struct ListNode* next;
};
 
struct ListNode* removeElements(struct ListNode* head, int val)
{
    struct ListNode* prev = NULL;
    struct ListNode* cur = head;
    while (cur != NULL)
    {
        if (cur->val != val)
        {
            prev = cur;
            cur = cur->next;
        }
        else
        {
            if (head->val == val)
            {
                head = cur->next;
                free(cur);
                cur = head;
            }
            else
            {
                prev->next = cur->next;
                free(cur);
                cur = prev->next;
            }

        }
    }

    return head;
}

第一种方法
//int main()
//{
//    struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
//    struct ListNode* n2 = (struct ListNode*)malloc(sizeof(struct ListNode));
//    struct ListNode* n3 = (struct ListNode*)malloc(sizeof(struct ListNode));
//    struct ListNode* n4 = (struct ListNode*)malloc(sizeof(struct ListNode));
//    struct ListNode* n5 = (struct ListNode*)malloc(sizeof(struct ListNode));
//    n1->val = 1;
//    n2->val = 2;
//    n3->val = 3;
//    n4->val = 4;
//    n5->val = 5;
//
//    n1->next = n2;
//    n2->next = n3;
//    n3->next = n4;
//    n4->next = n5;
//    n5->next = NULL;
//
//    struct ListNode* pret = removeElements(n1, 1);
//    while(pret)
//    {
//        printf("%d->", pret->val);
//        pret = pret->next;
//    }
//
//	return 0;
//}

//第二种方法
int main()
{
    //这种方法可以减少开辟用来维护地址的指针，只需要开辟一个指针即可
    struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
    if (n1 == NULL)
    {
        exit(-1);
    }
    n1->val = 1;

    n1->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    if (n1->next == NULL)
    {
        exit(-1);
    }
    n1->next->val = 2;

    n1->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    if (n1->next->next == NULL)
    {
        exit(-1);
    }
    n1->next->next->val = 3;

    n1->next->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    if (n1->next->next->next == NULL)
    {
        exit(-1);
    }
    n1->next->next->next->val = 4;

    n1->next->next->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    if (n1->next->next->next->next == NULL)
    {
        exit(-1);
    }
    n1->next->next->next->next->val = 5;
    n1->next->next->next->next->next = NULL;
    //前面n个都是结点，最后一个next是让后面的第n个结点的next指向空

    struct ListNode* pret = removeElements(n1, 1);
    while (pret)
    {
        printf("%d->", pret->val);
        pret = pret->next;
    }

    return 0;
}

3.4带头双向循环链表的实现，也叫带哨兵位双向循环链表

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

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

//初始化
ListNode* ListInit(LTDataType x);
//销毁
void ListDestory(ListNode* phead);
//打印
void ListPrint(ListNode* phead);
//尾插
void ListPushBack(ListNode* phead, LTDataType x);
//尾删
void ListPopBack(ListNode* pHead);
//头插
void ListPushFront(ListNode* phead, LTDataType x);
//头删
void ListPopFront(ListNode* phead);
//查找
ListNode* ListFind(ListNode* phead, LTDataType x);
//在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
//删除pos位置的结点
void ListErase(ListNode* pos);

初始化

打印

尾插

头插

尾删

头删

销毁

注：1.通过以上函数接口为什么双向带头循环链表不用传二级指针？主要是带头链表不需要改变头的位置，列如单链表进行头插头删就会改变头节点，头插要把新的节点设置为头节点，头删需要把头节点的下一个节点设置为头节点，并且头插头删，尾插尾删的时间复杂度是O(1)。

2.在头插和尾插判断链表是不是空的时候，只需要对phead进行断言判断，如果为空则报错，尾删、头删只用判断哨兵位的next不等于自己，则链表不为空，相对于不带头链表写起来比较方便。

完整代码：

main.c

#include "List.h"

void test1()
{
	ListNode* plist = ListInit(-1);
	ListNode* ret = NULL;
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPrint(plist);

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

	ListPushFront(plist, 2);
	ListPushFront(plist, 3);
	ListPushFront(plist, 4);
	ListPrint(plist);

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

	ret = ListFind(plist, 2);
	ListInsert(ret, 3);
	ListPrint(plist);

	ListErase(ret);
	ListPrint(plist);

	ListDestory(plist);
}

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

list.c

#include "List.h"

//开辟结点
ListNode* BuyListNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;

	return newnode;
}

//初始化
ListNode* ListInit(LTDataType x)
{
	ListNode* phead = BuyListNode(x);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

//销毁
void ListDestory(ListNode* phead)
{
	assert(phead);

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

	free(phead);
	phead = NULL;
}

//判断链表有没有结点
bool LTEmpty(ListNode* phead)
{
	assert(phead);

	return phead->next == phead;//相等为真返回一个非零值，假返回0
}

//打印
void ListPrint(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;//phead不存储有效结点，应该把phead的next赋值给cur
	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

//尾插
void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	ListNode* cur = phead->prev;//phead的prev指向的是尾节点的地址，next指向的是头结点的位置

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

//尾删
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	ListNode* tail = phead->prev;
	ListNode* tmp = tail->prev;

	tmp->next = phead;
	phead->prev = tmp;
	free(tail);
	tail = NULL;
}

//头插
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	ListNode* first = phead->next;

	newnode->next = first;
	first->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;
}
//头删
void ListPopFront(ListNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	ListNode* first = phead->next;
	ListNode* tmp = first->next;

	tmp->prev = phead;
	phead->next = tmp;
	free(first);
	first = NULL;
}

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

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

	return NULL;
}
//在pos的前面进行插入
//在pos的前面插入，为什么不在pos的后面插入？因为在pos的前面插入可以复用在头插和尾插的接口上
//在pos的后面插入，只能复用在尾插的接口上。
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newnode = BuyListNode(x);

	newnode->prev = pos->prev;//newnode的prev指向pos的上一个
	pos->prev->next = newnode;//pos的上一个的next指向newnode
	newnode->next = pos;
	pos->prev = newnode;
}
//删除pos位置的结点
//Erase可以复用在头删和尾删函数上
void ListErase(ListNode* pos)
{
	assert(pos);

    //1.直接使用pos来进行链接
	pos->prev->next = pos->next;//pos的前一个节点的next指向pos的下一个节点
	pos->next->prev = pos->prev;//pos的下一个节点的prev指向pos的前一个节点
	//2.也可以定义一个指针来帮忙进行链接

    //最后释放pos
	free(pos);
	pos = NULL;
}

list.h

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

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

//初始化
ListNode* ListInit(LTDataType x);
//销毁
void ListDestory(ListNode* phead);
//打印
void ListPrint(ListNode* phead);
//尾插
void ListPushBack(ListNode* phead, LTDataType x);
//尾删
void ListPopBack(ListNode* pHead);
//头插
void ListPushFront(ListNode* phead, LTDataType x);
//头删
void ListPopFront(ListNode* phead);
//查找
ListNode* ListFind(ListNode* phead, LTDataType x);
//在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
//删除pos位置的结点
void ListErase(ListNode* pos);

4.顺序表和链表的区别

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