数据结构与算法学习总结5

封装链表：

    1、单链表

    2、静态链表

    3、循环链表

    4、双向循环链表 prev next

    5、Linux内核链表

    6、通用链表

        结点：

            void* ptr;

            指针域

       

        运算：常规功能+回调函数

           

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

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

//    删除结点
static void* _del_list(Node* node)
{
    node->prev->next = node->next;
    node->next->prev = node->prev;
    void* p = node->ptr;
    free(node);
    return p;
}

//    根据位置访问结点
static Node* _index_list(List* list,size_t index)
{
    if(index >= list->size) return NULL;
    if(index <= list->size/2)
    {
        Node* n = list->head->next;
        while(index--) n = n->next;
        return n;
    }
    else
    {
        Node* n = list->head->prev;
        while(++index < list->size)  n = n->prev;
        return n;
    }
}

//    在两个结点之间插入一个结点
static void _add_list(Node* prev,Node* next,void* ptr)
{
    Node* node = create_node(ptr);
    prev->next = node;
    node->prev = prev;
    next->prev = node;
    node->next = next;
}

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

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

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

//    插入
bool insert_list(List* list,size_t index,void* ptr)
{
    Node* node = _index_list(list,index);
    if(NULL == node) return false;
    _add_list(node->prev,node,ptr);
}

//    按位置删除
void* del_index_list(List* list,size_t index)
{
    Node* node = _index_list(list,index);
    if(NULL == node) return NULL;
    list->size--;
    return _del_list(node);
}

//    按值删除
void* del_value_list(List* list,void* ptr,int (*cmp)(const void*,const void*))
{
    for(Node* n=list->head->next; list->head!=n; n=n->next)
    {
        if(0 == cmp(ptr,n->ptr))    
        {
            list->size--;
            return _del_list(n);    
        }
    }
    return NULL;
}

//    查询
void* query_list(List* list,void* ptr,Comper cmp)
{
    for(Node* n=list->head->next;n!=list->head;n=n->next)
    {
        if(0 == cmp(ptr,n->ptr)) return n->ptr;
    }
    return NULL;
}

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

//    排序
void sort_list(List* list,Comper cmp)
{
    for(Node* i=list->head->next;list->head!=i->next; i=i->next)
    {
        for(Node* j=j->next; list->head!=j; j=j->next)
        {
            if(0 > cmp(i->ptr,j->ptr))
            {
                void* temp = i->ptr;
                i->ptr = j->ptr;
                j->ptr = temp;
            }
        }
    }
}

//    清空
void* clear_list(List* list)
{
    Node* node = list->head->next;
    while(node != list->head)
    {
        Node* temp = node;
        node = node->next;
        free(temp->ptr);
        free(temp);
    }
    list->head->next = list->head;
    list->head->prev = list->head;
    list->size = 0;
}

//    销毁
void* destory_list(List* list)
{
    clear_list(list);
    free(list->head);
    free(list);
    
}

//    遍历 show是回调函数由调用者提供
void show_list(List* list,void (*show)(void*))
{
    for(Node* n=list->head->next; list->head!=n; n=n->next)
    {
        show(n->ptr);
        
    }
}
 

LIST_H文件

#ifndef LIST_H
#define LIST_H

#include <stdio.h>
#include <stdbool.h>

//    重定义啦函数指针类型 新类型名叫Comper
//    定义函数指针变量 Cmoper cmp 
//    cmp即函数指针变量
typedef int (*Comper)(const void*,const void*);

//    通用链表结点
typedef struct Node
{
    void* ptr;
    struct Node* prev;
    struct Node* next;
}Node;

//    通用链表结构
typedef struct List
{
    Node* head;
    size_t size;
}List;

//    创建链表
List* create_list(void);
//    头添加
void add_head_list(List* list,void* ptr);
//    尾添加
void add_tail_list(List* list,void* ptr);
//    插入
bool insert_list(List* list,size_t index,void* ptr);
//    按位置删除
void* del_index_list(List* list,size_t index);
//    按值删除
void* del_value_list(List* list,void* ptr,int (*cmp)(const void*,const void*));
//    查询
void* query_list(List* list,void* ptr,Comper cmp);
//    访问
void* access_list(List* list,size_t index);
//    排序
void sort_list(List* list,Comper cmp);
//    清空
void* clear_list(List* list);
//    销毁
void* destory_list(List* list);
//    遍历
void show_list(List* list,void (*show)(void*));

#endif//LIST_H