不带头结点循环双链表

不带头结点循环双链表

有问题可以一起在评论区讨论

#include<stdio.h>
#include<malloc.h>

typedef int ElemType;

typedef struct DNode {
	ElemType data;
	struct DNode* prior, * next;
}DNode, * DLinkList;

//按位查找
DNode* GetElem(DLinkList, int);

//按值查找
DNode* LocateElem(DLinkList, ElemType);

//求表长
int Length(DLinkList);

//按位序插入
bool DListInsert(DLinkList&, int, ElemType);

//指定结点后插操作
bool InsertNextNode(DNode*, ElemType);

//指定结点前插操作
bool InsertPriorNode(DLinkList&, DNode*, ElemType);

//按位序删除
bool DListDelete(DLinkList&, int, ElemType&);

//指定结点删除
bool DeleteNode(DLinkList&, DNode*);

//删除该结点的后续结点
bool DeleteNextDNode(DLinkList& , DNode*);

//删除该双链表
void DestoryList(DLinkList&);

//初始化双链表
bool InitDListList(DLinkList&);

//判断双链表是否为空
bool Empty(DLinkList);

//尾插法建立双链表
bool DListTailInsert(DLinkList&);

//头插法建立双链表
bool DListHeadInsert(DLinkList&);

//后向遍历链表
void Traverse(DLinkList);

//前向遍历链表
void TraverseForward(DLinkList);


int main(void) {

	DLinkList L;
	//1.尾插法创建双链表
	DListTailInsert(L);

	//2.头插法创建双链表
	//DListHeadInsert(L);

	//3.按位查找
	DNode* p = GetElem(L, 3);
	//4.按值查找
	/*p = LocateElem(L, 999);
	if (p == NULL) {
		printf("该值不存在\n");
	}
	else {
		printf("该值为：%d\n", p->data);
	}*/

	//5.求表长
	//printf("表长为：%d\n", Length(L));

	//6.按位序插入
	//Traverse(L);
	/*bool flag = DListInsert(L, 4, 777);
	if (!flag) {
		printf("插入失败!\n");
	}*/

	//7.指定结点前插操作
	//bool flag = InsertPriorNode(L, p, 5555);
	//8.指定结点后插操作
	/*bool flag = InsertNextNode(p, 5555);
	if (!flag) {
		printf("插入失败!\n");
	}*/
	//9.按位序删除
	//Traverse(L);
	/*ElemType e;
	bool flag = DListDelete(L, 3, e);*/
	//10.删除该结点的后续结点
	/*bool flag = DeleteNextDNode(L, p);
	if (!flag) {
		printf("删除失败!\n");
	}
	else {
		printf("删除成功!\n");
	}*/
	//11.删除该双链表
	DestoryList(L);

	Traverse(L);

	TraverseForward(L);

	return 0;

}


DNode* GetElem(DLinkList L, int i) {
	if (i < 1 || L == NULL) {
		return NULL;
	}

	DNode* p = L;
	int j = 1;
	while (j < i) {
		p = p->next;
		j++;
		if (p == L) {
			return NULL;
		}
	}

	return p;
}


DNode* LocateElem(DLinkList L, ElemType e) {
	if (L == NULL) {
		return NULL;
	}

	DNode* p = L;

	while (p->data != e) {
		p = p->next;
		if (p == L) {
			return NULL;
		}
	}

	return p;

}

int Length(DLinkList L) {
	if (L == NULL) {
		return 0;
	}
	DNode* p = L;
	int j = 0;
	do{
		p = p->next;
		j++;
	} while (p != L);

	return j;
}

bool DListInsert(DLinkList& L, int i, ElemType e) {
	if (i < 1) {
		return false;
	}

	if (i == 1) {
		return InsertPriorNode(L, L, e);
	}

	DNode* p = GetElem(L, i - 1);


	return InsertNextNode(p, e);
}

bool InsertNextNode(DNode* p, ElemType e) {
	if (p == NULL) {
		return false;
	}

	//创建新结点
	DNode* s = (DNode*)malloc(sizeof(DNode));
	if (s == NULL) {
		return false;	//内存分配失败情况
	}

	s->data = e;
	s->next = p->next;
	p->next->prior = s;
	p->next = s;
	s->prior = p;

	return true;
}

bool InsertPriorNode(DLinkList& L, DNode* p, ElemType e) {

	if (p == NULL || L == NULL) {
		return false;
	}
	//创建新结点
	DNode* s = (DNode*)malloc(sizeof(DNode));
	if (s == NULL) {
		return false;	//内存分配失败情况
	}
	s->data = e;
	s->prior = p->prior;
	p->prior->next = s;
	p->prior = s;
	s->next = p;
	if (p == L) {
		L = s;
	}
	return true;
}

bool DListDelete(DLinkList& L, int i, ElemType& e) {

	//查找出该位序结点
	DNode* p = GetElem(L, i);
	if (p != NULL) {
		e = p->data;
		return DeleteNode(L, p);
	}
	else {
		return false;
	}


}

bool DeleteNode(DLinkList& L, DNode* p) {

	if (p == NULL || L == NULL) {
		return false;
	}

	if (p == L) {	//删除的是首结点
		if (L->next == L) { //只有一个结点
			free(L);
			L = NULL;
		}
		else {
			L = L->next;
			p->next->prior = p->prior;
			p->prior->next = p->next;
			free(p);
		}
		return true;
	}

	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);

	return true;

}

bool DeleteNextDNode(DLinkList& L, DNode* p) {
	if (p == NULL || L == NULL) {
		return false;
	}
	return DeleteNode(L,p->next);

}

void DestoryList(DLinkList& L) {
	if (L == NULL) {
		return;
	}
	while (L != NULL) {
		DeleteNextDNode(L,L);
	}
	free(L);
	L = NULL;
}

bool InitDListList(DLinkList& L) {
	L = NULL;
	return true;

}

bool Empty(DLinkList L) {
	return  L == NULL;
}

bool DListTailInsert(DLinkList& L) {

	if (!InitDListList(L)) {
		return false;
	}

	ElemType x;
	DNode* s, * r = L;
	printf("输入9999即退出\n");
	printf("请输入:\n");
	scanf("%d", &x);
	while (x != 9999) {
		s = (DNode*)malloc(sizeof(DNode));
		if (s == NULL) {
			return false;
		}
		s->data = x;
		if (r == NULL) {	//插入第一个结点
			s->next = s;
			s->prior = s;
			L = s;
		}
		else {
			s->next = r->next;
			r->next = s;
			s->prior = r;
		}
		r = s;

		scanf("%d", &x);
	}
	L->prior = r;
	return true;

}

bool DListHeadInsert(DLinkList& L) {
	if (!InitDListList(L)) {
		return false;
	}
	DNode* s;
	ElemType x;
	printf("输入9999即退出\n");
	printf("请输入:\n");
	scanf("%d", &x);
	while (x != 9999) {
		s = (DNode*)malloc(sizeof(DNode));
		if (s == NULL) {
			return false;
		}

		s->data = x;
		if (L == NULL) {
			s->next = s;
			s->prior = s;
		}else {
			s->prior = L->prior;
			s->next = L;
			L->prior = s;
		}
		L = s;
		scanf("%d", &x);
	}
	L->prior->next = L;
	return true;

}

void Traverse(DLinkList L) {
	if (L == NULL) {
		return;
	}

	DNode* p = L;

	do{
		printf("%d\t", p->data);
		p = p->next;
	} while (p != L);
	printf("\n");
}

void TraverseForward(DLinkList L) {
	if (L == NULL) {
		return;
	}
	DNode* p = L->prior;
	do{
		printf("%d\t", p->data);
		p = p->prior;
	} while (p != L->prior);
	printf("\n");
}