常用数据结构 双向循环链表（一）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct _listLink tListLink;
typedef struct _listNode tListNode;
typedef struct _listLink tListLink;
typedef struct _listCtrl tListCtrl;
typedef struct _list     tList;
	
typedef struct _listLink{
tListNode *prev;
tListNode *next;
}tListLink;

typedef struct _listNode{
tListLink link;
void* pElement;
}tListNode;

typedef struct _listCtrl{
unsigned char (*isEmpty)(tList *list);
void (*addHead)(tList *list, void* pElement, unsigned int size);
void (*addTail)(tList *list, void* pElement, unsigned int size);
void (*delHead)(tList *list);
void (*delTail)(tList *list);
void (*delAll)(tList *list);
void (*getHeadElement)(tList *list,void *pElement, unsigned int size);
}tListCtrl;

typedef struct _list{
unsigned int count;
tListNode *pHead;
tListCtrl ctrl;
}tList;


typedef struct data{
int idx;
char name[64];
}tListElement;

static void _addToHead(tList* list, void* pElement, unsigned int size)
{
	tListNode* newNode = NULL;
	tListNode* leftNode = list->pHead;
	tListNode* rightNode = list->pHead->link.next;

	newNode = (tListNode*)malloc(sizeof(tListNode));
	if(newNode == NULL) {/*异常处理*/}

	if(size > 0 && pElement != NULL)
	{

		newNode->pElement = (void*)malloc(sizeof(char)*size);
		if(newNode->pElement == NULL){free(newNode);/*异常处理*/}
		memcpy(newNode->pElement, pElement, size);
	}
	else
	{
		newNode->pElement = NULL;
	}

	newNode->link.next = rightNode;
	newNode->link.prev = leftNode;
	leftNode->link.next = newNode;
	rightNode->link.prev = newNode;

	printf(" %s(%d): add head node: %p \n",__FUNCTION__, __LINE__, newNode);

}

static void _addToTail(tList* list, void* pElement, unsigned int size)
{
	tListNode* newNode = NULL;
	tListNode* leftNode = list->pHead->link.prev;
	tListNode* rightNode = list->pHead;

	newNode = (tListNode*)malloc(sizeof(tListNode));
	if(newNode == NULL) {/*异常处理*/}

	if(size > 0 && pElement != NULL)
	{

		newNode->pElement = (void*)malloc(sizeof(char)*size);
		if(newNode->pElement == NULL){free(newNode);/*异常处理*/}
		memcpy(newNode->pElement, pElement, size);
	}
	else
	{
		newNode->pElement = NULL;
	}

	newNode->link.next = rightNode;
	newNode->link.prev = leftNode;
	leftNode->link.next = newNode;
	rightNode->link.prev = newNode;

	printf(" %s(%d): add tail node: %p \n",__FUNCTION__, __LINE__, newNode);

}

static unsigned char _isEmpty(tList* list)
{
	if(list->pHead->link.next == list->pHead)
	{
		return 1;
	}
	else
	{
		return 0;
	}

}
static void _delNode(tListNode* node)
{

	if(node->pElement != NULL) {free(node->pElement);}

	free(node);

	printf(" %s(%d): del node: %p \n",__FUNCTION__, __LINE__, node);

}
static void _delHead(tList* list)
{
	tListNode* delNode;
	tListNode* leftNode;
	tListNode* rightNode;

	if(_isEmpty(list)) {/*异常处理*/ return;}

	delNode = list->pHead->link.next;
	leftNode = list->pHead;
	rightNode = delNode->link.next;


	leftNode->link.next = rightNode;
	rightNode->link.prev = leftNode;

	if(delNode->pElement != NULL) {free(delNode->pElement);}

	free(delNode);

	printf(" %s(%d): del tail node: %p \n",__FUNCTION__, __LINE__, delNode);

}

static void _delTail(tList* list)
{
	tListNode* delNode;
	tListNode* leftNode;
	tListNode* rightNode;

	if(_isEmpty(list)) {/*异常处理*/ return;}

	delNode = list->pHead->link.prev;
	leftNode = delNode->link.prev;
	rightNode = list->pHead;


	leftNode->link.next = rightNode;
	rightNode->link.prev = leftNode;

	if(delNode->pElement != NULL) {free(delNode->pElement);}

	free(delNode);

	printf(" %s(%d): del tail node: %p \n",__FUNCTION__, __LINE__, delNode);

}

static void _delAll(tList* list)
{
	tListNode* cur;
	tListNode* tmp = list->pHead->link.next;

	if(_isEmpty(list)) {/*异常处理*/ return;}

	while(tmp != list->pHead)
	{
		cur = tmp;
		tmp = tmp->link.next;
		_delNode(cur);
	}

	list->pHead->link.next = list->pHead;
	list->pHead->link.prev = list->pHead;

	printf(" %s(%d): dil all \n",__FUNCTION__, __LINE__);

}

static void _getHeadElement(tList* list, void* pElement, unsigned int size)
{
	tListNode* fistNode = list->pHead->link.next;

	if(fistNode == NULL) {/*异常处理*/return;}

	if(size > 0 && pElement != NULL)
	{
		memcpy(pElement, fistNode->pElement, size);
	}

}

tList* createList(void)
{
	tList* list = NULL;
	tListNode* head = NULL;

	list = (tList*)malloc(sizeof(tList));
	if(list == NULL) 
	{
		/*这里添加异常处理*/
		printf(" %s(%d) error! \n",__FUNCTION__, __LINE__);
		return NULL;
	}

	head = (tListNode*)malloc(sizeof(tListNode));
	if(head == NULL) 
	{
		/*这里添加异常处理*/
		printf(" %s(%d) error! \n",__FUNCTION__, __LINE__);
		free(list);
		return NULL;
	}

	memset(list,0,sizeof(tList));
	list->pHead = head;
	list->ctrl.isEmpty = _isEmpty;
	list->ctrl.addHead = _addToHead;
	list->ctrl.addTail = _addToTail;
	list->ctrl.delHead = _delHead;
	list->ctrl.delTail = _delTail;
	list->ctrl.getHeadElement = _getHeadElement;
	list->ctrl.delAll = _delAll;

	memset(head,0,sizeof(tListNode));
	head->link.next = head;
	head->link.prev = head;
	head->pElement = NULL;

	return list;
}

void destroyList(tList* list)
{
	_delAll(list);
	free(list);
}

int main(void)
{


	tListElement elment = {1,"This is name"};

	tList* my_list = createList();

	my_list->ctrl.addHead(my_list,&elment, sizeof(tListElement));

	elment.idx++;
	my_list->ctrl.addHead(my_list,&elment, sizeof(tListElement));

	elment.idx++;
	my_list->ctrl.addHead(my_list,&elment, sizeof(tListElement));


	my_list->ctrl.getHeadElement(my_list,&elment, sizeof(tListElement));
	printf(" %s(%d) %d = %s \n",__FUNCTION__, __LINE__, elment.idx, elment.name);
	my_list->ctrl.delHead(my_list);
	my_list->ctrl.getHeadElement(my_list,&elment, sizeof(tListElement));
	printf(" %s(%d) %d = %s \n",__FUNCTION__, __LINE__, elment.idx, elment.name);
	my_list->ctrl.delHead(my_list);
	my_list->ctrl.getHeadElement(my_list,&elment, sizeof(tListElement));
	printf(" %s(%d) %d = %s \n",__FUNCTION__, __LINE__, elment.idx, elment.name);
	my_list->ctrl.delHead(my_list);

	destroyList(my_list);

return 0;
}