再学C的数据结构---双向循环链表

DCLish.h

 

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

typedef int Elemtype;

typedef struct Node
{
	Elemtype data;
	struct Node* prio;
	struct Node* next;
}Node,*PNode;

typedef struct List
{
	PNode first;
	PNode last;
	int size;
}List;

void InitDCList(List *plist);
Node* BuyNode(const Elemtype x);

void show_list(const List* plist);
void push_back(List* plist, const Elemtype x);
void push_front(List* plist, const Elemtype x);
void pop_back(List* plist);
void pop_front(List* plist);
void insert_val(List* plist, const Elemtype x);

Node* find(const List* plist, const Elemtype key);
int length(const List* plist);

void delete_val(List* plist, const Elemtype key);
void sort(List* plist);
void resver(List *plist);
void clear(List *plist);
void destroy(List* plist);

DCLish.cpp

#include "DCList.h"


Node* BuyNode(const Elemtype x)
{
	Node* newnode = (Node*)malloc(sizeof(Node));
	assert(newnode != NULL);
	newnode->data = x;
	newnode->next = newnode->prio = NULL;
	return newnode;
}



void InitDCList(List *plist)
{
	assert(plist != NULL);
	plist->first = BuyNode(0);
	plist->last = plist->first;
	plist->last->next = plist->first;
	plist->first->prio = plist->last;
	plist->size = 0;
}



void push_back(List* plist, const Elemtype x)
{
	assert(plist != NULL);
	Node* newnode = BuyNode(x);

	plist->last->next = newnode;
	newnode->prio = plist->last;
	newnode->next = plist->first;
	plist->last = newnode;
	++plist->size;
}



void show_list(const List* plist)
{
	assert(plist != NULL);
	Node* p = plist->first->next;
	while (p != plist->first)
	{
		printf("%d-->", p->data);
		p = p->next;
	}
	printf("NULL\n");
}



void push_front(List* plist, const Elemtype x)
{
	assert(plist != NULL);
	Node* newnode = BuyNode(x);
	newnode->next = plist->first->next;
	plist->first->next->prio = newnode;
	newnode->prio = plist->first;
	plist->first->next = newnode;
	if (plist->first == plist->last)
	{
		plist->last = newnode;
	}
	++plist->size;
}



void pop_back(List* plist)
{
	assert(plist != NULL);
	assert(plist->size != 0);
	Node* tmp = plist->last->prio;
	free(plist->last);
	tmp->next = plist->first;
	plist->first->prio = tmp;
	plist->last = tmp;
	--plist->size;
}



void pop_front(List* plist)
{
	assert(plist != NULL);
	assert(plist->size != 0);
	
	Node* tmp = plist->first->next;
	plist->first->next = tmp->next;
	tmp->next->prio = plist->first;
	free(tmp);
	if (--plist->size == 0)
	{
		plist->last = plist->first;
	}
}



void insert_val(List* plist, const Elemtype x)
{
	assert(plist != NULL);

	Node* p = plist->first;
	
	while (p->next != plist->first && x > p->next->data)
	{
		p = p->next;
	}

	if (p->next == plist->first)
	{
		push_back(plist, x);
	}
	else
	{
		Node* newnode = BuyNode(x);
		newnode->next = p->next;
		p->next->prio = newnode;
		newnode->prio = p;
		p->next = newnode;
		++plist->size;
	}
}



Node* find(const List* plist, const Elemtype key)
{
	assert(plist != NULL);
	assert(plist->size != 0);

	Node* p = plist->first->next;

	while (p != plist->first && p->data != key) 
	{
		p = p->next;
	}

	return p;
}



int length(const List* plist)
{
	assert(plist != NULL);
	return plist->size;
}



void delete_val(List* plist, const Elemtype key)
{
	assert(plist != NULL);
	Node* node = find(plist, key);
	if (node == plist->first)
	{
		printf("无此数据！\n");
	}
	else
	{
		Node* p = node->prio;
		p->next = node->next;
		node->next->prio = p;
		if (node == plist->last)
		{
			plist->last = p;
		}
		free(node);
		--plist->size;
	}
}



void sort(List* plist)
{
	assert(plist != NULL);
	if (plist->size == 1 || plist->size == 0)
	{
		return;
	}

	Node* p = plist->first->next;
	Node* q = p->next;

	p->next = plist->first;
	plist->last = p;
	plist->first->prio = p;

	while (q != plist->first)
	{
		Node* tmp = q;
		q = q->next;

		p = plist->first;

		while (p->next != plist->first && tmp->data > p->next->data)
		{
			p = p->next;
		}

		if (p->next == plist->first)
		{
			plist->last->next = tmp;
			tmp->prio = plist->last;
			tmp->next = plist->first;
			plist->last = tmp;
		}
		else
		{
			
			tmp->next = p->next;
			p->next->prio = tmp;
			tmp->prio = p;
			p->next = tmp;
		}

		++plist->size;
	}
}



void resver(List *plist)
{
	assert(plist != NULL);
	if (plist->size == 1 || plist->size == 0)
	{
		return;
	}

	Node* p = plist->first->next;
	Node* q = p->next;

	p->next = plist->first;
	plist->last = p;
	plist->first->prio = p;

	while (q != plist->first)
	{
		Node* tmp = q;
		q = q->next;

		tmp->next = plist->first->next;
		plist->first->next->prio = tmp;
		tmp->prio = plist->first;
		plist->first->next = tmp;
	}
}



void clear(List *plist)
{
	assert(plist != NULL);
	Node* p = plist->first->next;
	while (p != plist->first)
	{
		Node* tmp = p;
		p = p->next;
		free(tmp);
	}
	plist->size = 0;
	plist->last = plist->first;
}



void destroy(List* plist)
{
	assert(plist != NULL);
	clear(plist);
	free(plist->first);
	plist->first = plist->last = NULL;
}