双向循环链表

带头结点的双向循环链表

List.h

#pragma once

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

typedef int _LTDataType;

typedef struct ListNode
{
	struct ListNode * _next;
	struct ListNode * _prev;
	_LTDataType _data;
}ListNode;

typedef struct List
{
	struct ListNode * _head;
}List;

void ListInit(List * lt);
void ListDestory(List * lt);

void ListPushBack(List * lt, _LTDataType x);
void ListPushFront(List * lt, _LTDataType x);

void ListPopBack(List * lt);
void ListPopFront(List * lt);

ListNode * BuyListNode();
ListNode * ListFind(List * lt, _LTDataType x);

void ListInsert(ListNode * pos, _LTDataType x);
void ListErase(ListNode * pos);

void ListRemove(List * lt, _LTDataType x);
void ListRemoveAll(List * lt, _LTDataType x);

int ListSize(List * lt);
int ListisEmpty(List * lt);

void ListPrint(List * lt);

List.c

#include"List.h"

void ListInit(List * lt)
{
	assert(lt);
	lt->_head = BuyListNode();
	lt->_head->_next = lt->_head;
	lt->_head->_prev = lt->_head;
}

void ListDestory(List * lt)
{
	ListNode * cur = lt->_head->_next;
	assert(lt);
	while (cur != lt->_head)
	{
		ListNode * del = cur;
		cur = del->_next;
		free(del);
		del = NULL;
	}
	free(lt->_head);
	lt->_head = NULL;
}

void ListPushBack(List * lt, _LTDataType x)
{
	assert(lt);
	ListInsert(lt->_head, x);
}

void ListPushFront(List * lt, _LTDataType x)
{
	assert(lt);
	ListInsert(lt->_head->_next, x);
}

void ListPopBack(List * lt)
{
	assert(lt);
	ListErase(lt->_head->_prev);
}

void ListPopFront(List * lt)
{
	assert(lt);
	ListErase(lt->_head->_next);
}

ListNode * BuyListNode()
{
	ListNode * newNode = (ListNode *)malloc(sizeof(ListNode));
	assert(newNode);
	newNode->_data = 0;
	newNode->_next = NULL;
	newNode->_prev = NULL;
	return newNode;
}

ListNode * ListFind(List * lt, _LTDataType x)
{
	ListNode * node = lt->_head->_next;
	assert(lt);
	while (node != lt->_head)
	{
		if (node->_data == x)
		{
			return node;
		}
		node = node->_next;
	}
	return NULL;
}

void ListInsert(ListNode * pos, _LTDataType x)
{
	ListNode * newNode = BuyListNode();
	assert(pos && newNode);
	newNode->_data = x;
	pos->_prev->_next = newNode;
	newNode->_next = pos;
	newNode->_prev = pos->_prev;
	pos->_prev = newNode;
}

void ListErase(ListNode * pos)
{
	assert(pos);
	pos->_prev->_next = pos->_next;
	pos->_next->_prev = pos->_prev;
	free(pos);
	pos = NULL;
}

void ListRemove(List * lt, _LTDataType x)
{
	ListNode * node = NULL;
	assert(lt);
	node = ListFind(lt, x);
	ListErase(node);
}

void ListRemoveAll(List * lt, _LTDataType x)
{
	ListNode * cur = NULL;
	assert(lt);
	cur = lt->_head->_next;
	while (cur != lt->_head)
	{
		if (cur->_data == x)
		{
			ListNode * del = cur;
			cur = del->_prev;
			ListErase(del);
		}
		cur = cur->_next;
	}
}

int ListSize(List * lt)
{
	int size = 0;
	ListNode * cur = lt->_head->_next;
	assert(lt);
	while (cur != lt->_head)
	{
		size++;
		cur = cur->_next;
	}
	return size;
}

int ListisEmpty(List * lt)
{
	assert(lt);
	return lt->_head->_next == lt->_head ? 0 : 1;
}

void ListPrint(List * lt)
{
	ListNode * cur = NULL;
	assert(lt);
	cur = lt->_head->_next;
	while (cur != lt->_head)
	{
		printf("%d->>",cur->_data);
		cur = cur->_next;
	}
	printf("NULL\n");
}

Test.c

#include"List.h"

void testList()
{
	List list;
	ListNode * pos = NULL;

	ListInit(&list);

	printf("SIZE : %d\n", ListSize(&list));
	printf("ISEMPTY : %d\n", ListisEmpty(&list));

	ListPushFront(&list, 1);
	ListPushFront(&list, 2);
	ListPushFront(&list, 3);
	ListPushFront(&list, 4);
	ListPushFront(&list, 5);

	ListPushBack(&list, 6);
	ListPushBack(&list, 7);
	ListPushBack(&list, 8);
	ListPushBack(&list, 9);
	ListPushBack(&list, 0);

	ListPrint(&list);

	pos = ListFind(&list, 0);
	ListInsert(pos, 9);
	ListPrint(&list);

	ListErase(pos);
	ListPrint(&list);

	ListPopFront(&list);
	ListPrint(&list);

	ListPopBack(&list);
	ListPrint(&list);

	ListRemove(&list, 9);
	ListPrint(&list);

	ListPushBack(&list, 1);
	ListPushBack(&list, 2);
	ListPushBack(&list, 1);
	ListPrint(&list);
	ListRemoveAll(&list, 1);
	ListPrint(&list);

	printf("SIZE : %d\n", ListSize(&list));
	printf("ISEMPTY : %d\n", ListisEmpty(&list));

	ListDestory(&list);
}

int main()
{
	testList();
	return 0;
}