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