双向循环带头链表的增删查改

 test.c文件

#define _CRT_SECURE_NO_WARNINGS
#include"SLTlist.h"


//尾插
void Test()
{
	node* Plist = SLTIinit();

	Pushback(Plist,1);
	Pushback(Plist,2);
	Pushback(Plist,3);
	Pushback(Plist,4);
	SLTPrint(Plist);
}   



//头插
void Test2()
{
	node* Plist = SLTIinit();
	SLTPusFront(Plist, 1);
	SLTPusFront(Plist, 2);
	SLTPusFront(Plist, 3);
	SLTPusFront(Plist, 4);
	SLTPrint(Plist);

	SLTPrint(Plist);
}


//头删
void Test3()
{


	node* Plist = SLTIinit();
	SLTPusFront(Plist, 1);
		SLTPusFront(Plist, 2);
		SLTPusFront(Plist, 3);
		SLTPusFront(Plist, 4);
		SLTPrint(Plist);
		SLTPopFront(Plist);
		SLTPopFront(Plist);
		SLTPopFront(Plist);
		SLTPopFront(Plist);
		SLTPrint(Plist);
}


//尾删
void Test4()
{
	node* Plist = SLTIinit();
	SLTPusFront(Plist, 1);
	SLTPusFront(Plist, 2);
	SLTPusFront(Plist, 3);
	SLTPusFront(Plist, 4);
	SLTPrint(Plist);
SLTPopback(Plist);

SLTPrint(Plist);
}



void Test5()
{
	node* Plist = SLTIinit();

	Pushback(Plist, 1);
	Pushback(Plist, 2);
	Pushback(Plist, 3);
	Pushback(Plist, 4);
	SLTPrint(Plist);

	//查改serach
	node* serach=SLTFind(Plist, 4);
	serach->data= 100;
	SLTPrint(Plist);


	//serach之前插入
	/*SLTForntserach(serach,12);
	SLTPrint(Plist);*/



	serach之后插入
	SLTserachBack( serach, 13);
	SLTPrint(Plist);


	//删除serach之后的数
	SLTPopserachBack(serach);
	SLTPrint(Plist);



	//删除serach之前的数
	SLTPopserachFront(serach);
	SLTPrint(Plist);


	//删除serach

	SLTPopserach(serach);
	SLTPrint(Plist);

}

int main()
{

	Test5();
	//Test();
	return 0;
}

要注意的一点就是初始化函数在调用Plist时

node* Plist = NULL;
SLTIinit(plist);

这样不行，因为把指针传过去要用二级指针来接收，我们的SLTIinit类型没用二级指针

node* SLTIinit()
{
	 node* Phead = BuyList(9);

	Phead->prev = Phead;
	Phead->next = Phead;
	return Phead;
}

 

所以我们这里的返回值用指针接收一下，改成

node*Plist=SLTIinit();

SLTlist.h文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int DataType;
typedef struct SLTNode
{
	DataType data;
	struct SLTNode* next;
	struct SLTNode* prev;
}node;

//开辟函数
node* BuyList(DataType x);
//初始化
node* SLTIinit();
//尾插
void Pushback(node* Phead,DataType x);
//头插
void SLTPusFront(node* Phead, DataType x);
//头删
void SLTPopFront(node* Phead);
//尾删
void SLTPopback(node* Phead);
//查找
node* SLTFind(node* Phead, DataType x);
//在serach前插入
void SLTForntserach(node* serach, DataType x);

//在serach后插入
void SLTserachBack( node* serach, DataType x);

//删除serach后的数
void SLTPopserachBack( node* serach);

//删除serach前的数
void SLTPopserachFront(node* serach);
//删除serach
void SLTPopserach(node* serach);

//打印函数
void SLTPrint(node* Phead);

 

SLTlist.c文件

 

#define _CRT_SECURE_NO_WARNINGS
#include"SLTlist.h"


//开辟函数
node* BuyList(DataType x)
{
	node* newnode = (node*)malloc(sizeof(node));
	if (newnode == NULL)
	{
		printf("malloc fail");
	}
	
	newnode->next = NULL;
	newnode->data = x;
	newnode->prev = NULL;
	return newnode;
}



//初始化
node* SLTIinit()
{
	 node* Phead = BuyList(9);

	Phead->prev = Phead;
	Phead->next = Phead;
	return Phead;
}



//尾插
void Pushback(node* Phead,DataType x)
{
	assert(Phead);
	node* newnode= BuyList(x);
	node* tail=Phead->prev ;

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




//头插
void SLTPusFront(node* Phead, DataType x)
{
	node* newnode = BuyList(x);
	node* tail = Phead->next;
	newnode->next = tail;
	Phead->next= newnode;
	tail->prev = newnode;
	newnode->prev = Phead;


}



//头删
void SLTPopFront(node* Phead)
{
	 node* tail= Phead->next ;
	 node* serach=tail->next ;
	 Phead->next = serach;
	 serach->prev = Phead;
	 free(tail);
}



//尾删
void SLTPopback(node* Phead)
{
	node* tail=Phead->prev;
	node* serach = tail->prev;
	Phead->prev = serach;
	serach->next = Phead;

}



//查找
node* SLTFind(node* Phead,DataType x)
{
	node* cur = Phead;
	while (cur->data != x)
	{
		cur = cur->next;
	}
	return cur;
}


//在serach前插入
void SLTForntserach(node* serach,DataType x)
{
	node* newnode = BuyList(12);
	newnode->data = x;
	node* serachprev = serach->prev;
	serachprev->next = newnode;
	newnode->next = serach;
	serach->prev = newnode;
}



//在serach后插入
void SLTserachBack(node* serach, DataType x)
{
	node* newnode = BuyList(13);
	newnode->data = x;
	node* serachnext = serach->next;
	serach->next = newnode;
	newnode->next = serachnext;
	newnode->prev = serach;
}



//删除serach后的数
void SLTPopserachBack(node* serach)
{
	node* serachnext = serach->next;
	node* serachnextnext = serachnext->next;
	serach->next = serachnextnext;
	serachnextnext->prev = serach;
}



//删除serach
void SLTPopserach(node* serach)
{
	node* serachprev = serach->prev;
	node* serachnext = serach->next;
	serachprev->next = serachnext;
	serachnext->prev = serachprev;
	free(serach);

}



//删除serach前的数
void SLTPopserachFront(node* serach)
{
	node* serachprev = serach->prev;
	node* serachprrevprev = serachprev->prev;
	serachprrevprev->next = serach;
	serach->prev = serachprrevprev;


}



//打印函数
void SLTPrint(node* Phead)
{
	node* cur = Phead->next;

	printf("哨兵位<=>");
	while(cur!=Phead)
	{
	
		printf("%d<=>", cur->data);
	cur = cur->next;
	}
	printf("\n");

}

十分钟手撕双向带头循环链表，不用写头插尾插

先写在serach前插入函数，然后尾插调用

//尾插
void Pushback(node* Phead,DataType x)
{
	SLTForntserach(Phead, x);
}

实现尾插效果

 

 先写在serach后插入函数，然后头插函数调用

//头插
void SLTPusFront(node* Phead, DataType x)
{
	
	SLTserachBack(Phead, x);

}

 实现头插效果

 

 然后再写在serach后插入韩式，然后尾插函数调用

//尾删
void SLTPopback(node* Phead)
{
	SLTPopserachBack(Phead);

}

实现尾删效果

 

 先写删除serach前的数函数，再用头删函数调用

//头删
void SLTPopFront(node* Phead)
{
	SLTPopserachBack(Phead);

}

 实现头删效果