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

DList.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;

Node* BuyNode(Elemtype x);

void InitDList(List* plist);

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);

 

DList.cpp

#include "DList.h"


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



void InitDList(List* plist)
{
	assert(plist != NULL);
	plist->first = plist->last = BuyNode(0);
	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;
	plist->last = newnode;
	
	++plist->size;
}



void show_list(const List* plist)
{
	assert(plist != NULL);

	Node* p = plist->first->next;
	while (p != NULL)
	{
		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;
	newnode->prio = plist->first;

	if (plist->first == plist->last)
	{
		plist->last = newnode;
	}
	else
	{
		plist->first->next->prio = newnode;
	}
	plist->first->next = newnode;
	++plist->size;
}



void pop_back(List* plist)
{
	assert(plist != NULL);
	assert(plist->size != 0);

	Node* tmp = plist->last->prio;
	plist->last->prio = NULL;
	free(plist->last);
	tmp->next = NULL;
	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;
	if (tmp->next != NULL)
	{
		tmp->next->prio = plist->first;
	}

	tmp->next = NULL;
	tmp->prio = NULL;
	free(tmp);
	--plist->size;
}



void insert_val(List* plist, const Elemtype x)
{
	assert(plist != NULL);
	if (plist->size == 0)
	{
		push_back(plist, x);
		return;
	}
	Node* newnode = BuyNode(x);
	Node* p = plist->first;
	while (p->next != NULL && x > p->next->data)
	{
		p = p->next;
	}

	newnode->prio = p;
	newnode->next = p->next;

	if (p->next != NULL)
	{
		p->next->prio = newnode;
	}
	else
	{
		plist->last = newnode;
	}
	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 != NULL && 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);
	assert(plist->size != 0);
	Node* p = find(plist, key);
	Node* q = p->prio;
	if (p != NULL)
	{
		q->next = p->next;
		p->prio = q;
	}
	if (p->next == NULL)
	{
		plist->last = q;
	}
	free(p);
	--plist->size;
}



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

	Node* p = plist->first->next;
	Node* q = p->next;
	p->next = NULL;
	q->prio = NULL;
	plist->last = p;

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

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

		tmp->prio = p;
		tmp->next = p->next;

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

}



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

	Node* p = plist->first->next;
	Node* q = p->next;
	p->next = NULL;
	q->prio = NULL;
	plist->last = p;

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

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



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



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