一、结构差异
- 单向链表
- 定义：单向链表是链表的一种，每个节点包含数据域和指向下一个节点的指针域。
- 特点：链表的链接方向是单向的，即只能从头节点开始顺序访问到尾节点。
- 节点结构：通常包含数据域和指向下一个节点的指针（如
struct node { int data; struct node* next; }）。
- 双向链表
- 定义：双向链表也是链表的一种，但与单向链表不同，它的每个节点包含两个指针，分别指向直接前驱和直接后继。
- 特点：从双向链表中的任意一个节点开始，都可以方便地访问前驱节点和后继节点。
- 节点结构：通常包含数据域、指向前一个节点的指针和指向下一个节点的指针（如
struct node { int data; struct node* prev; struct node* next; }）。
- 内核链表
- 定义：内核链表是Linux内核中常用的一种链表结构，主要用于内核内部的数据组织和管理。
- 特点：内核链表是一种双向循环链表，具有高度的通用性和扩展性。它的节点不包含具体的数据域，而是通过嵌入到具体的数据结构中来实现数据的存储。
- 节点结构：内核链表节点只包含两个指针，分别指向链表中的前一个节点和后一个节点（如
struct list_head { struct list_head* next; struct list_head* prev; }）。
二、功能差异
- 单向链表
- 插入操作：只能从链表的头部或尾部进行插入，插入时需要遍历链表找到插入位置。
- 删除操作：删除节点时，需要遍历链表找到待删除节点的前一个节点，然后修改其指针域。
- 访问效率：单向链表的访问效率较低，特别是在查找特定节点时。
- 双向链表
- 插入操作：可以在链表的任意位置进行插入，因为每个节点都保存了前驱和后继节点的指针。
- 删除操作：删除节点时，可以直接通过前驱或后继节点的指针来修改链表结构，无需遍历。
- 访问效率：双向链表的访问效率高于单向链表，特别是在需要频繁访问前驱或后继节点时。
- 内核链表
- 插入操作：提供了专门的函数（如
list_add、list_add_tail）来在链表的头部或尾部插入节点，也可以在其他节点之后插入。 - 删除操作：提供了
list_del函数来删除节点，该函数会自动处理链表结构的更新。 - 遍历和访问：提供了遍历链表（如
list_for_each）和获取节点数据（如list_entry）的宏和函数，方便使用。
三、应用差异
- 单向链表
- 适用场景：适用于数据量不大，且主要进行顺序访问的场景。
- 优点：实现简单，节点结构紧凑。
- 缺点：访问效率低，特别是在查找和删除节点时。
- 双向链表
- 适用场景：适用于需要频繁访问前驱或后继节点的场景，如双向队列、图的邻接表等。
- 优点：访问效率高，特别是在需要频繁进行前驱或后继节点访问时。
- 缺点：节点结构相对复杂，占用空间较大。
- 内核链表
- 适用场景：主要用于Linux内核内部的数据组织和管理，如进程、文件、模块等对象的链表管理。
- 优点：高度通用和扩展性，可以方便地嵌入到各种数据结构中。同时，内核链表提供了丰富的操作函数和宏，方便使用。
- 缺点：主要适用于内核开发场景，对于一般的应用程序开发来说可能过于复杂和庞大
四，内核链表相关代码
//main.c
#include "klink.h"
#include "flight.h"
#include <stdio.h>
int main(int argc, const char *argv[])
{
KLink_t *ppasslink = create_klink();
if (NULL == ppasslink)
{
return -1;
}
struct passager *ppass = create_passager("zhangsan", 2024, 1, 'r');
push_klink_head(ppasslink, ppass);
ppass = create_passager("lisi", 2024, 2, 'g');
push_klink_head(ppasslink, ppass);
ppass = create_passager("wanger", 2024, 3, 'y');
push_klink_head(ppasslink, ppass);
klink_for_each(ppasslink, print_passager);
char card = 'r';
KNode_t *ptmp = find_klink(ppasslink, &card, compare_by_card);
if (ptmp != NULL)
{
print_passager(ptmp);
}
KLink_t *pfltlink = create_klink();
if (NULL == pfltlink)
{
return -1;
}
struct flight *flt = create_flight(2024, "西安", "上海");
push_klink_head(pfltlink, flt);
flt = create_flight(2023, "西安", "北京");
push_klink_head(pfltlink, flt);
flt = create_flight(2022, "北京", "上海");
push_klink_head(pfltlink, flt);
klink_for_each(pfltlink, print_flight);
pop_klink_head(pfltlink);
klink_for_each(pfltlink, print_flight);
destroy_klink(pfltlink);
destroy_klink(ppasslink);
return 0;
}
//link.c 链表的相关操作
#include "klink.h"
#include <stdio.h>
#include <stdlib.h>
KLink_t *create_klink()
{
KLink_t *pklink = malloc(sizeof(KLink_t));
if (NULL == pklink)
{
perror("fail malloc");
return NULL;
}
pklink->phead = NULL;
pklink->clen = 0;
pthread_mutex_init(&(pklink->mutex), NULL);
return pklink;
}
int push_klink_head(KLink_t *pklink, void *p)
{
KNode_t *pnode = (KNode_t *)p;
pnode->pnext = NULL;
pnode->ppre = NULL;
pnode->pnext = pklink->phead;
if (pklink->phead != NULL)
{
pklink->phead->ppre = pnode;
}
pklink->phead = pnode;
pklink->clen++;
return 0;
}
void klink_for_each(KLink_t *pklink, void (*pfun)(void *))
{
KNode_t *pnode = pklink->phead;
while (pnode != NULL)
{
pfun(pnode);
pnode = pnode->pnext;
}
printf("\n");
}
KNode_t *find_klink(KLink_t *pklink, void *t, CMP_t pfun)
{
KNode_t *pnode = pklink->phead;
while (pnode != NULL)
{
if (pfun(t, pnode))
{
return pnode;
}
pnode = pnode->pnext;
}
return NULL;
}
int is_empty_klink(KLink_t *pklink)
{
return NULL == pklink->phead;
}
int pop_klink_head(KLink_t *pklink)
{
if (is_empty_klink(pklink))
return 0;
KNode_t *pdel = pklink->phead;
pklink->phead = pdel->pnext;
if (pklink->phead != NULL)
{
pklink->phead->ppre = NULL;
}
free(pdel);
pklink->clen--;
return 1;
}
void destroy_klink(KLink_t *pklink)
{
while (!is_empty_klink(pklink))
{
pop_klink_head(pklink);
}
free(pklink);
}
//flight.c 链表节点的填充
#include "flight.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct passager *create_passager(char *name, int flt_num, int sit_num, char card)
{
struct passager *p = malloc(sizeof(struct passager));
if (NULL == p)
{
perror("fail malloc");
return NULL;
}
strcpy(p->name, name);
p->flt_num = flt_num;
p->sit_num = sit_num;
p->card = card;
return p;
}
void print_passager(void *pnode)
{
struct passager *p = (struct passager *)pnode;
printf("%s %d %d %c\n", p->name, p->flt_num, p->sit_num, p->card);
}
struct flight *create_flight(int flt_num, char *src, char *dst)
{
struct flight *f = malloc(sizeof(struct flight));
if (NULL == f)
{
perror("fail malloc");
return NULL;
}
f->flt_num = flt_num;
strcpy(f->src, src);
strcpy(f->dst, dst);
return f;
}
void print_flight(void *pnode)
{
struct flight *f = (struct flight *)pnode;
printf("%d %s %s\n", f->flt_num, f->src, f->dst);
}
int compare_by_card(void *t, void *pnode)
{
struct passager *p = (struct passager *)pnode;
if (p->card == *((char *)t))
{
return 1;
}
return 0;
}
//link.h
#ifndef __KLINK_H__
#define __KLINK_H__
#include <pthread.h>
typedef int (*CMP_t)(void *, void *);
typedef struct knode
{
struct knode *ppre;
struct knode *pnext;
}KNode_t;
typedef struct klink
{
KNode_t *phead;
int clen;
pthread_mutex_t mutex;
}KLink_t;
extern int push_klink_head(KLink_t *pklink, void *p);
extern KLink_t *create_klink();
extern void klink_for_each(KLink_t *pklink, void (*pfun)(void *));
extern KNode_t *find_klink(KLink_t *pklink, void * t, CMP_t pfun);
extern int pop_klink_head(KLink_t *pklink);
extern int is_empty_klink(KLink_t *pklink);
extern void destroy_klink(KLink_t *pklink);
#endif
//flight.h
#ifndef __FLIGHT_H__
#define __FLIGHT_H__
#include "klink.h"
struct passager
{
KNode_t node;
char name[64];
int flt_num;
int sit_num;
char card;
};
struct flight
{
KNode_t node;
int flt_num;
char src[64];
char dst[32];
};
extern struct passager *create_passager(char *name, int flt_num, int sit_num, char card);
extern void print_passager(void *pnode);
extern struct flight *create_flight(int flt_num, char *src, char *dst);
extern void print_flight(void *pnode);
extern int compare_by_card(void *t, void *pnode);
#endif
847
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
