数据结构-双向链表

目录

 定义结构体内容

初始化及申请一个空节点

链表的打印

链表的尾插

链表的头插

链表的尾删

链表的头删

链表的查找

链表插入

链表选定位置删除

链表的摧毁

判断链表里是否为空

完整的代码List.c

---

上个博客里，我们介绍到了单链表，但是单链表有许多限制，比如

1：进行尾插时需要一个一个遍历先，找到最后一个结点的指针才可以进行连接。

2：进行删除插入等操作时需要判断是不是空指针或者指针是否为空

所以现入一个新的链表形式————双向链表（带头双向循环链表），概念图为如下：

结构看起来比较复杂，但对于数据的处理会十分简单

---

 定义结构体内容

typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* next;//下一个地址
	struct ListNode* prev;//前一个地址
	LTDataType data;//存放的数据大小
}LTNode;

初始化及申请一个空节点

方法实则同单链表，此处仅提供代码

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));//开辟和结构体一样大小的字节空间
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	 
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

LTNode* LTInit()
{
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

链表的打印

void LTPrint(LTNode* phead)//形式就是单链表的形式
{
	assert(phead);//断言，防止传入的是空指针
	LTNode* cur = phead->next;//第一个是哨兵位，元素为空不打印
	while (cur != phead)//一次循环后就会回到开头phead处，故判断条件为这个
	{
		printf("%d<==>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

链表的尾插

若进行尾插，那么效果图应该为此

 D4的前指针要跟d3进行相互连接，然后D4的尾指针要和头指针进行连接

void LTPushBack(LTNode* phead, LTDataType x)
//双链表可以直接跳过中间的节点，进行连接
{
	assert(phead);

	LTNode* tail=phead->prev; //由phead的头指针可以找到最后一个结点
    LTNode* newnode=BuyLTNode(x);

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

链表的头插

链表的头插需要在哨兵位head和第一个结点直接插入结点,概念图如下：

 

void LTPushFront(LTNode* phead, LTDataType x)
{
   
	assert(phead);
	LTNode* newnode=BuyLTNode(x);
    
    LTNode* next=phead->next;
    newnode->next=next;
    next->prev=newnode;
    phead->next=newnode;
    newnode->prev=phead;
}

链表的尾删

 将为结点定为倒数第二个结点即可，并且要进行重新的连接

void LTPopBack(LTNode* phead)
{
	assert(phead);
	LTNode* tail=phead->prev;//找到倒数第一个结点
    LTNode* Tailprev=tail->prev;//导、倒数第二个结点
    
    phead->prev=Tailprev;
    Tailprev->next=phead;
    free(tail);

}

链表的头删

 

void LTPopFront(LTNode* phead)
{
	assert(phead);
	LTNode* next = phead->next;

	phead->next = next->next;
	next->next->prev = phead;
	free(next);
}

仅进行结点指向的改变即可

链表的查找

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

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

		cur = cur->next;
	}

	return NULL;
}

链表插入

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

	LTNode* prev = pos->prev;//要先找到前一个元素，再进行前后的连接
	LTNode* newnode = BuyLTNode(x);

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

链表选定位置删除

找到要删除位置前后的结点，将这两个结点进行连接

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

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

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

链表的摧毁

方法同单向链表

void LTDestroy(LTNode* phead)
{
	assert(phead);

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

判断链表里是否为空

bool LTEmpty(LTNode* phead)//判断是否链表里的元素不存在
{
	assert(phead);

	return phead->next == phead;
}

完整的代码List.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"List.h"

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));//开辟和结构体一样大小的字节空间
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	 
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

LTNode* LTInit()
{
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

void LTPrint(LTNode* phead)//形式就是单链表的形式
{
	assert(phead);

	printf("guard<==>");
	LTNode* cur = phead->next;//第一个是哨兵位，元素为空不打印
	while (cur != phead)//一次循环后就会回到开头phead处，故判断条件为这个
	{
		printf("%d<==>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

bool LTEmpty(LTNode* phead)//判断是否链表里的元素不存在
{
	assert(phead);

	return phead->next == phead;
}

void LTPushBack(LTNode* phead, LTDataType x)
//双链表可以直接跳过中间的节点，进行连接
{
	assert(phead);

	LTInsert(phead, x);//直接插入在phead前面，实则就是插在最后一个元素的后面

	//LTNode* tail = phead->prev;//由于循环head的头部就是整个链表的尾部
	//LTNode* newnode = BuyLTNode(x);

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

//void LTPushFront(LTNode* phead, LTDataType x)//这个方法无法解决下一个元素为空的情况
//{
//   
//	assert(phead);
//	LTNode* newnode = BuyLTNode(x);
//
//	newnode->next = phead->next;
//	phead->next->prev = newnode;
//
//	phead->next = newnode;
//	newnode->prev = phead;
//}

void LTPushFront(LTNode* phead, LTDataType x)
{
	/*assert(phead);
	LTNode* newnode = BuyLTNode(x);
	LTNode* first = phead->next;//记录下一个元素的内容,可以保证若是下一个元素不存在的情况


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

	newnode->next = first;
	first->prev = newnode;*/

	LTInsert(phead->next, x);
}

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));//不为空再进行尾删
	LTErase(phead->prev);

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

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

}

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* next = phead->next;

	phead->next = next->next;
    phead->next->prev = phead;
	free(next);

	
}



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

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

		cur = cur->next;
	}

	return NULL;
}

// 在pos之前插入
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* prev = pos->prev;//要先找到前一个元素，再进行前后的连接
	LTNode* newnode = BuyLTNode(x);

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

// 删除pos位置的值
void LTErase(LTNode* pos)
{
	assert(pos);

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

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

void LTDestroy(LTNode* phead)
{
	assert(phead);

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


	free(phead);
}