【数据结构与算法】双向通用链表的功能实现

.h文件

#ifndef LIST_H
#define LIST_H
#include <stdio.h>
#include <stdbool.h>

#define swap(a,b) {typeof(a) t=a; a=b; b=t;}

typedef struct Node
{
	void* data;
	struct Node* prev;
	struct Node* next;
}Node;

typedef struct List
{
	Node* head;
	size_t size;
}List;

typedef void (*SHOW)(const void*);

typedef int (*CMP)(const void*,const void*);

// 创建结点
Node* create_node(void* data);

// 创建链表
List* create_list(void);

// 销毁链表
void destroy_list(List* list);

// 删除所有结点
void clear_list(List* list);

// 判断链表是否为空
bool empty_list(List* list);

// 头添加
void add_head_list(List* list,void* data);

// 尾添加
void add_tail_list(List* list,void* data);

// 插入
bool insert_list(List* list,size_t index,void* data);

// 头删除
bool del_head_list(List* list);

// 尾删除
bool del_tail_list(List* list);

// 按位置删除
bool del_index_list(List* list,size_t index);

// 按值删除
bool del_value_list(List* list,void* data,CMP cmp);

// 返回头结点元素
void* head_list(List* list);

// 返回尾结点元素
void* tail_list(List* list);

// 访问
void* access_list(List* list,size_t index);

// 查询
void* query_list(List* list,void* data,CMP cmp);

// 排序
void sort_list(List* list,CMP cmp);

// 删除重复
void unique_list(List* list,CMP cmp);

// 反转链表
void reverse_list(List* list);

// 链表长度
size_t size_list(List* list);

// 遍历
void show_list(List* list,SHOW show);

#endif//LIST_H

.c文件

#include <stdlib.h>
#include "list.h"

static void _add_node(Node* prev,Node* next,void* data)
{
	Node* node = create_node(data);
	prev->next = node;
	node->prev = prev;
	node->next = next;
	next->prev = node;
}

static void _del_node(Node* node)
{
	node->prev->next = node->next;
	node->next->prev = node->prev;
	free(node->data);
	free(node);
}

static Node* _index_list(List* list,size_t index)
{
	if(index < list->size/2)
	{
		Node* node = list->head->next;
		while(index--) node = node->next;
		//printf("%s:%p\n",__func__,node->data);
		return node;
	}
	else
	{
		Node* node = list->head->prev;
		while(++index < list->size) node = node->prev;
		//printf("%s:%p\n",__func__,node->data);
		return node;
	}
}

static Node* _value_list(List* list,void* data,CMP cmp)
{
	for(Node* n=list->head->next; n!=list->head; n=n->next)
	{
		if(0 == cmp(n->data,data))
		{
			return n;
		}
	}

	return NULL;
}
// 创建结点
Node* create_node(void* data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->prev = node;
	node->next = node;
	return node;
}

// 创建链表
List* create_list(void)
{
	List* list = malloc(sizeof(List));
	list->head = create_node(NULL);
	list->size = 0;
	return list;
}

// 销毁链表
void destroy_list(List* list)
{
	while(del_head_list(list));
	_del_node(list->head);
	free(list);
}

// 删除所有结点
void clear_list(List* list)
{
	while(del_head_list(list));
}

// 判断链表是否为空
bool empty_list(List* list)
{
	return list->head->next == list->head;	
}

// 头添加
void add_head_list(List* list,void* data)
{
	_add_node(list->head,list->head->next,data);
	list->size++;
}

// 尾添加
void add_tail_list(List* list,void* data)
{
	_add_node(list->head->prev,list->head,data);
	list->size++;
}

// 插入
bool insert_list(List* list,size_t index,void* data)
{
	if(index >= list->size)
		return false;
	
	Node* node = _index_list(list,index);
	_add_node(node->prev,node,data);
	list->size++;
	return true;
}

// 头删除
bool del_head_list(List* list)
{
	if(empty_list(list))
		return false;

	_del_node(list->head->next);
	list->size--;
	return true;
}

// 尾删除
bool del_tail_list(List* list)
{
	if(empty_list(list))
		return false;

	_del_node(list->head->prev);
	list->size--;
	return true;
}

// 按位置删除
bool del_index_list(List* list,size_t index)
{
	if(index >= list->size)
		return false;

	_del_node(_index_list(list,index));
	list->size--;
	return true;
}

// 按值删除
bool del_value_list(List* list,void* data,CMP cmp)
{
	Node* node = _value_list(list,data,cmp);
	if(NULL == node)
		return false;

	_del_node(node);
	list->size--;
	return true;
}

// 返回头结点元素
void* head_list(List* list)
{
	return list->head->next->data;
}

// 返回尾结点元素
void* tail_list(List* list)
{
	return list->head->prev->data;
}

// 访问
void* access_list(List* list,size_t index)
{
	if(index >= list->size)
		return NULL;
	return _index_list(list,index)->data;
}

// 查询
void* query_list(List* list,void* data,CMP cmp)
{
	Node* node = _value_list(list,data,cmp);
	if(NULL == node)
		return NULL;
	return node->data;
}

// 排序
void sort_list(List* list,CMP cmp)
{
	bool flag = true;
	for(Node* e=list->head->prev; flag&&e!=list->head->next; e=e->prev)
	{
		flag = false;
		for(Node* s=list->head->next; s!=e; s=s->next)
		{
			if(1==cmp(s->data,s->next->data))
			{
				swap(s->data,s->next->data);
				flag = true;
			}
		}
	}
}

// 删除重复
void unique_list(List* list,CMP cmp)
{
	for(Node* node=list->head->next; node!=list->head; node=node->next)
	{
		Node* temp = node->next;
		while(temp != list->head)
		{
			if(0 == cmp(node->data,temp->data))
			{
				temp = temp->next;
				_del_node(temp->prev);
				list->size--;
				continue;
			}
			temp = temp->next;
		}
	}
}

// 反转链表
void reverse_list(List* list)
{
	Node* left = list->head->next;
	Node* right = list->head->prev;
	do{
		swap(left->data,right->data);
		left = left->next;
		right = right->prev;
	}while(left!=right && left->next != right);
}

// 链表长度
size_t size_list(List* list)
{
	return list->size;
}

// 遍历
void show_list(List* list,SHOW show)
{
	for(Node* n=list->head->next; n!=list->head; n=n->next)
	{
		show(n->data);
	}
}

int main()
{
	void show(const void* data)
	{
		printf("%d ",*(int*)data);
	}
	int cmp(const void* p1,const void* p2)
	{
		if(*(int*)p1 > *(int*)p2)
			return 1;
		if(*(int*)p1 < *(int*)p2)
			return -1;
		return 0;
	}

	List* list = create_list();
	for(int i=0; i<10; i++)
	{
		int* p = malloc(sizeof(int));
		*p = rand()%90+10;
		add_tail_list(list,p);
	}
	sort_list(list,cmp);
	unique_list(list,cmp);
	show_list(list,show);
	printf("\n");
	reverse_list(list);
	show_list(list,show);
}