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

SCList.h

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

typedef int Elemtype;

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


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

void InitSCList(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);

SCList.cpp

#include "SCList.h"


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

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



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



void push_front(List* plist, const Elemtype x)
{
	assert(plist != NULL);
	Node* newnode = BuyNode(x);
	newnode->next = plist->first->next;
	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* p = plist->first;
	while (p->next != plist->last)
	{
		p = p->next;
	}
	free(p->next);
	plist->last = p;
	p->next = plist->first;
	--plist->size;
}


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



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

	Node* p = plist->first;

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

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

	if (newnode->next == plist->first)
	{
		plist->last = 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)
	{
		if (p->data == key)
		{
			return p;
		}
		p = p->next;
	}
	return NULL;
}



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


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

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

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

		if (plist->last->next != plist->first)
		{
			plist->last = tmp;
		}		
	}
}



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

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


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

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

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



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


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

}


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