双链表的增删改查

双链表的增删改查

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

/*
0.创建结构体DNode{
	结构体的数据域
	结构体的前驱指针域prior
	结构体的后继指针域next
}
*/
typedef int ElemType;
typedef struct DNode 
{
	ElemType data;
	struct DNode *prior; //结构体的前驱指针域prior
	struct DNode *next; //结构体的后驱指针域next
}DNode,*DLinkList;

/*
1.头插法创建双向链表
DLinkList Dlist_head_insert(DLinkList &DL){
	动态申请一个空间，让结构体指针DL(头结点)指向
	初始化头结点的前驱指针域，后继指针域
	对数据进行读取
	循环判断{
		 动态申请空间，让结构体指针s指向
		 数据域赋值
		 将头指针的后继指针域赋值给s的后继指针域
		 判断是否是插入第一个节点{
			让DL的后继指针域指向的那个节点的前驱指针域指向s
		 }
		 让s的前驱指针域指向头结点
		 让DL的后继指针域指向s
		 进行下一次的数据读取
	}
}
*/
DLinkList Dlist_head_insert(DLinkList &DL) 
{
	int x; DNode* s;
	DL = (DLinkList)malloc(sizeof(DNode));//动态申请一个空间，让结构体指针DL(头结点)指向
	DL->prior = NULL;//初始化头结点的前驱指针域，后继指针域
	DL->next = NULL; 
	
	scanf("%d", &x); //对数据进行读取
	while (x != 9999)
	{
		s = (DNode*)malloc(sizeof(DNode));//动态申请空间，让结构体指针s指向
		s->data = x;//数据域赋值
		s->next = DL->next;
		if (DL->next!=NULL)
		{
			DL->next->prior = s; //让DL的后继指针域指向的那个节点的前驱指针域指向s
		}
		DL->next = s; //让DL的后继指针域指向s
		s->prior = DL; //让s的前驱指针域指向头结点
		scanf("%d",&x);// 进行下一次的数据读取
	}
	return DL;
}

/*
2.链表的打印,从前往后遍历
这个子函数里面需要注意的是，这里没有用引用， 故不会改变主函数中L的值
*/
void PrintDList(DLinkList DL) {
	DL = DL->next;
	while (DL!=NULL)
	{
		printf("%3d",DL->data);
		DL = DL->next;
	}
}

/*
3.链表的打印，从后往前遍历
*/
void PrintDLlistRear(DLinkList DL)
{
	int length = 0;//记录链表的长度
	DNode *r = NULL;//创建尾指针变量
	DL = DL->next;
		
	while (DL != NULL) {
		r = DL;//使得尾指针指向最后的节点
		DL = DL->next;
		length++;//获取链表的长度
		
	}

	for (int i = 0; i < length; i++)
	{
		printf("%3d",r->data);
		r = r->prior;
	}
	printf("\n");
}

/*
4.尾插法创建双向链表
与单链表的尾插法类似，需要注意的是最后循环结束后再给尾部的后继指针域赋值为空
*/
DLinkList Dlist_tail_insert(DLinkList &DL) 
{
	int x; 
	DL = (DLinkList)malloc(sizeof(DNode));//创建头结点
	DNode *r,*s;
	DL->prior = NULL;//让头结点的前驱节点为NULL
	r = DL;//此时只有头结点，故尾指针指向头结点

	scanf("%d", &x);//数据读取
	while (x!=9999)
	{
		s = (DNode*)malloc(sizeof(DNode));//申请新的空间，让结构体指针s指向
		s->data = x;//给s的指针域赋值
		r->next = s;//让尾节点的后继指针域指向s
		s->prior = r;//让s的前驱指针域指向r
		r = s;//让r指向尾节点
		scanf("%d",&x);
	}
	r->next = NULL;//尾节点的后继指针域为NULL
	return DL;
}

/*
5.按序号查找节点值，并返回该节点
	DNode *GetElem(DLinkList DL,int i)
	{
		创建变量j用于统计第几个节点
		用于循环遍历，以及存储找到的节点
		判断查找的位置i是否是头结点,以及i查找的位置是否合法
		遍历循环找到位置为i的节点
	}
*/
DNode* GetElem(DLinkList DL, int i) 
{
	int j = 1;//创建变量j用于统计第几个节点
	DNode* p = DL->next;//用于循环遍历，以及存储找到的节点
	
	//判断查找的位置i是否是头结点,以及i查找的位置是否合法
	if (i==0)
	{
		return DL;
	}
	if (i<1)
	{
		return NULL;
	}

	//遍历循环找到位置为i的节点
	while (p&&j<i)
	{
		p = p->next;
		j++;
	}
	return p;
}

/*
6.新节点插入第i个位置
bool DListFrontInsert(DLinkList DL, int i, ElemType e)
{
	先找到前驱节点
	判断插入的位置是否合法(即前驱节点是否为NULL)
	申请新空间，让结构体指针变量s指向
	s的数据域赋值
	其余的操作与尾插创建链表类似，不再添加注释

}
*/
bool DListFrontInsert(DLinkList DL, int i, ElemType e) 
{
	DLinkList p = GetElem(DL, i - 1);//先找到前驱节点
	if (p==NULL)//判断插入的位置是否合法(即前驱节点是否为NULL)
	{
		return false;
	}

	DNode *s = (DNode*)malloc(sizeof(DNode));//申请新空间，让结构体指针变量s指向
	s->data = e;//s的数据域赋值
	s->next = p->next;
	p->next->prior = s;
	s->prior = p;
	p->next = s;
	return true;
}

/*
7.删除第i个位置的节点
bool DListDelete(DLinkList DL, int i)
{
	先找到待删除位置的前驱节点,用结构体指针变量p去接这个值
	判断带插入的前驱节点是否存在，不存在则插入的位置不合法
}
*/
bool DListDelet(DLinkList DL,int i)
{
	DNode *p = GetElem(DL, i - 1);
	if (p==NULL)
	{
		return false;
	}
	DNode *q = p->next;
	if (q==NULL)//删除的元素不存在
	{
		return false;
	}
	p->next = q->next;//断链
	//防止在删除最后一个节点的时候造成程序的崩溃
	if (q->next!=NULL)
	{
		q->next->prior = p;

	}
	free(q);//释放对应的空间
	return true;
}


int main()
{
	DLinkList DL;
	DLinkList search;

	//Dlist_head_insert(DL);//头插法创建双向链表
	//PrintDList(DL);
	//printf("\n");
	//PrintDLlistRear(DL);//链表的打印，从后往前遍历，不要求
	
	Dlist_tail_insert(DL);//尾插法创建双向链表
	PrintDList(DL);

	search = GetElem(DL, 2);//查找第2个元素
	if (search)
	{
		printf("\n按序号查找成功!\n");
		printf("%3d\n",search->data);
	}
	else
	{
		printf("按序号查找失败\n");
	}

	DListFrontInsert(DL, 3, 99);//在第三个位置插入99
	PrintDList(DL);

	DListDelet(DL, 2);//删除第二个位置
	PrintDList(DL);

	return 0;
}