基础数据结构9：双向循环链表

1.双向循环链表

#pragma once


typedef int ELEM_TYPE;

typedef struct DCList
{
	ELEM_TYPE  data;//数据域
	struct DCList* next;//后继指针
	struct DCList* prior;//前驱指针
}DCList, *PDClist;

//双向循环链表可执行的操作
//初始化
void Init_dclist(PDClist pl);

//头插
bool Insert_head(PDClist pl, int val);

//尾插
bool Insert_tail(PDClist pl, int val);

//按位置插入
bool Insert_pos(PDClist pl, int pos, int val);

//头删
bool Del_head(PDClist pl);

//尾删
bool Del_tail(PDClist pl);

//按位置删除
bool Del_pos(PDClist pl, int pos);

//按值删除，删除第一个值为val的节点，如果不存在，返回false
bool Del_val(PDClist pl, int val);

//查找，查找数值为val的节点，找到后返回其节点地址，否则返回NULL
 PDClist Search(PDClist pl, int val);

//判空
bool IsEmpty(PDClist pl);

//获取循环链表有效元素个数
int Get_length(PDClist pl);

//打印
void Show(PDClist pl);

//清空
void Clear(PDClist pl);

//销毁
void Destroy(PDClist pl);

void Destroy2(PDClist pl);

//寻找值为val的节点的前驱
PDClist Get_prior(PDClist pl, int val);

//寻找值为val的节点的后继

DCList* Buynode(int val);

#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#include"dclist.h"

//双向循环链表可执行的操作
//初始化
void Init_dclist(PDClist pl)
{
	assert(pl != NULL);
	if (NULL == pl) return;

	pl->next = pl;
	pl->prior = pl;

}

DCList* Buynode(int val)
{
	DCList* pnewnode = (DCList*)malloc(sizeof(DCList) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;
	pnewnode->next = NULL;
	pnewnode->prior = NULL;

	return pnewnode;
}

//头插
bool Insert_head(PDClist pl, int val)
{
	assert(pl != NULL);
	if (pl == NULL) return false;

	//DCList* pnewnode = (DCList*)malloc(sizeof(DCList) * 1);
	DCList* pnewnode = Buynode(val);
	assert(pnewnode != NULL);
	
	//插入
	pnewnode->next = pl->next;
	pnewnode->prior = pl;
	//证明在头插之前就至少存在一个有效节点
	if (pl->next != pl)
	{
		pl->next->prior = pnewnode;
	}
	//下一个节点的指向新节点，插入新节点
	pl->next = pnewnode;
	//永远指向最后一个节点，插入有效节点指针不需要修改，插入空链表修改指针
	if (pl->prior == pl)
	{
		pl->prior = pnewnode;
	}
	return true;
}

//尾插
bool Insert_tail(PDClist pl, int val)
{
	assert(pl != NULL);
	//创建新节点
	DCList* pnewnode = Buynode(val);
	assert(pnewnode != NULL);
	//找到合适的插入位置
	DCList* p = pl;
	for (pl; p->next != pl; p = p->next);
	//插入节点
	pnewnode->next = p->next;
	pnewnode->prior = p;

	p->next = pnewnode;
	pl->prior = pnewnode;
	return true;
}

//按位置插入
bool Insert_pos(PDClist pl, int pos, int val)
{
	assert(pl != NULL);
	DCList* pnewnode = Buynode(val);
	assert(pnewnode != NULL);
	DCList* p = pl;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	pnewnode->next = p->next;
	pnewnode->prior = p;
	if (p->next != pl)
	{
		p->next->prior = pnewnode;
	}
	else
	{
		pl->prior = pnewnode;
	}
	p->next = pnewnode;
	return true;
}

//头删
bool Del_head(PDClist pl)
{
	assert(pl != NULL && pl->next != pl);
	if (pl == NULL || pl->next == pl) return false;
	//删除
	DCList* p = pl->next;
	if (p->next == pl)
	{
		pl->next = pl->prior = pl;
		free(p);
		p = NULL;
	}
	else
	{
		pl->next = p->next;
		p->next->prior = pl;
		free(p);
		p = NULL;
	}
	return true;
}

//尾删
bool Del_tail(PDClist pl)
{
	assert(pl != NULL);
	DCList* p = pl;
	for (p; p->next != pl; p = p->next);

	if (pl->next == p)
	{
		pl->next = pl;
		pl->prior = pl;
	}
	else
	{
		p->prior->next = pl;
		pl->prior = p->prior;
	}
	free(p);
	p = NULL;
	return true;
}

//按位置删除
bool Del_pos(PDClist pl, int pos)
{
	assert(pl != NULL);
	if(pos == 0) return Del_head(pl);
	if (pos == Get_length(pl) - 1) return Del_tail;

	DCList* p = pl;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	DCList* q = p->next;
	p->next = q->next;
	q->next->prior = p;
	free(q);
	q = NULL;

	return true;
}

//按值删除，删除第一个值为val的节点，如果不存在，返回false
bool Del_val(PDClist pl, int val)
{
	assert(pl != NULL);
	DCList* p = Search(pl, val);
	if (p == NULL)
	{
		return false;
	}
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	p = NULL;

	return true;
}

//查找，查找数值为val的节点，找到后返回其节点地址，否则返回NULL
PDClist Search(PDClist pl, int val)
{
	assert(pl != NULL);
	DCList* p = pl->next;
	for (p; p != pl; p = p->next)
	{
		if (p->data == val)
		{
			return p;
		}
	}
	return NULL;
}

//判空
bool IsEmpty(PDClist pl)
{
	return pl->next == pl;
}

//获取循环链表有效元素个数
int Get_length(PDClist pl)
{
	int count = 0;
	DCList* p = pl->next;
	for (p; p != pl; p = p->next)
	{
		count++;
	}
	return count;
}

//打印
void Show(PDClist pl)
{
	DCList* p = pl->next;
	for (p; p != pl; p = p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

//清空
void Clear(PDClist pl)
{
	Destroy(pl);
}

//销毁
void Destroy(PDClist pl)
{
	while (pl->next != pl)
	{
		DCList* p = pl->next;
		pl->next = p->next;
		free(p);
		p = NULL;
	}

	pl->prior = pl;
}

void Destroy2(PDClist pl)//不用头节点
{
	DCList* p = pl->next;
	DCList* q;

	while (p != pl)
	{
		q = p->next;
		free(p);
		p = q;
	}
	pl->next = pl;
	pl->next->prior = pl;
}

//寻找值为val的节点的前驱
PDClist Get_prior(PDClist pl, int val)
{
	DCList* p = Search(pl, val);
	if (p == NULL)
	{
		return NULL;
	}
	return p->prior;
}

//寻找值为val的节点的后继
PDClist Get_next(PDClist pl, int val)
{
	DCList* p = Search(pl, val);
	if (p == NULL)
	{
		return NULL;
	}
	return p->next;
}