本文深入剖析了Nginx中用于构建高效链表操作的ngx_queue_t数据结构，包括其核心功能如插入排序、链表合并与拆分、获取链表中心元素等。此外，还提供了示例代码展示如何定义链表结构体、自定义比较函数以及如何初始化、插入元素、排序和遍历链表。通过这些，读者能够掌握如何在实际项目中利用ngx_queue_t优化数据处理。
nginx_图解nginx关键数据结构_双向链表ngx_queue_t
一、结构解析
ngx_queue_t是一种环形双向链表的数据结构，这个链表不会负责分配内存来存放元素，ngx_queue_t只是将已经分配好内存的元素用双向链表连接起来。
链表的优势在于，可以高效的执行插入、删除、合并等操作。移动链表元素的时候只需要修改链表的指向，因此适合频繁修改容器的情况。
nginx中，ngx_queue_t主要功能有
（1）实现了简单的插入排序
（2）支持两个链表的合并与拆分
（3）获取链表的中心元素，假设链表有n个元素，返回第n / 2 + 1个元素。
typedef struct ngx_queue_s ngx_queue_t;
//ngx_queue_t 结构体
struct ngx_queue_s {
ngx_queue_t *prev;
ngx_queue_t *next;
};
含有两个元素的 ngx_queue_t 结构
二、主要函数实现
/*
* Copyright (C) Igor Sysoev
* Copyright (C) Nginx, Inc.
*/
//ngx_queue.h
#include <ngx_config.h>
#include <ngx_core.h>
#ifndef _NGX_QUEUE_H_INCLUDED_
#define _NGX_QUEUE_H_INCLUDED_
typedef struct ngx_queue_s ngx_queue_t;
struct ngx_queue_s {
ngx_queue_t *prev;
ngx_queue_t *next;
};
/*
func：初始化链表容器
arg: q为链表容器结构体ngx_queue_t的指针
*/
#define ngx_queue_init(q) \
(q)->prev = q; \
(q)->next = q
/*
func：检测链表容器是否为空
arg: h为链表容器结构体ngx_queue_t的指针
*/
#define ngx_queue_empty(h) \
(h == (h)->prev)
/*
func：将元素x插到链表容器的头部
arg: h为链表容器结构体ngx_queue_t的指针，x为插入元素结构体中元素的指针
*/
#define ngx_queue_insert_head(h, x) \
(x)->next = (h)->next; \
(x)->next->prev = x; \
(x)->prev = h; \
(h)->next = x
#define ngx_queue_insert_after ngx_queue_insert_head
/*
func：将元素x插到链表容器的尾部
arg: h为链表容器结构体ngx_queue_t的指针，x为插入元素结构体中ngx_queue_t元素的指针
*/
#define ngx_queue_insert_tail(h, x) \
(x)->prev = (h)->prev; \
(x)->prev->next = x; \
(x)->next = h; \
(h)->prev = x
/*
func：返回容器中第一个元素的指针
arg: h为链表容器结构体ngx_queue_t的指针
*/
#define ngx_queue_head(h) \
(h)->next
/*
func：返回容器中最后一个元素的指针
arg: h为链表容器结构体ngx_queue_t的指针
*/
#define ngx_queue_last(h) \
(h)->prev
/*
func：返回容器的指针
arg: h为链表容器结构体ngx_queue_t的指针
*/
#define ngx_queue_sentinel(h) \
(h)
/*
func：返回链表元素q的下一个元素
arg: q为链表容器结构体ngx_queue_t的指针
*/
#define ngx_queue_next(q) \
(q)->next
/*
func：返回链表元素q的上一个元素
arg: q为链表容器结构体ngx_queue_t的指针
*/
#define ngx_queue_prev(q) \
(q)->prev
#if (NGX_DEBUG)
/*
func：移除链表中的x元素
arg: x为链表容器结构体ngx_queue_t的指针
*/
#define ngx_queue_remove(x) \
(x)->next->prev = (x)->prev; \
(x)->prev->next = (x)->next; \
(x)->prev = NULL; \
(x)->next = NULL
#else
#define ngx_queue_remove(x) \
(x)->next->prev = (x)->prev; \
(x)->prev->next = (x)->next
#endif
/*
func：拆分链表，h是链表容器（链表头），而q是链表h中的一个元素，这个方法将链表以q为界限，
拆分为两个链表h和n，其中q是后一部分的首元素。
arg: h为链表容器结构体ngx_queue_t的指针，q是链表h中的一个元素，n是后半部分的链表头
*/
#define ngx_queue_split(h, q, n) \
(n)->prev = (h)->prev; \
(n)->prev->next = n; \
(n)->next = q; \
(h)->prev = (q)->prev; \
(h)->prev->next = h; \
(q)->prev = n;
/*
func：合并链表，将n链表添加到h链表的末尾
arg: h和n为链表容器结构体ngx_queue_t的指针
*/
#define ngx_queue_add(h, n) \
(h)->prev->next = (n)->next; \
(n)->next->prev = (h)->prev; \
(h)->prev = (n)->prev; \
(h)->prev->next = h;
/*
func：返回q元素所属结构体（任何类型的struct，其中包含ngx_queue_t）的地址
arg: q为链表中的元素，type为链表元素所在的结构体名称，link是这个结构体中ngx_queue_t元素的的名字
*/
#define ngx_queue_data(q, type, link) \
(type *) ((u_char *) q - offsetof(type, link))
ngx_queue_t *ngx_queue_middle(ngx_queue_t *queue);
void ngx_queue_sort(ngx_queue_t *queue,
ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *));
#endif /* _NGX_QUEUE_H_INCLUDED_ */
/*
* Copyright (C) Igor Sysoev
* Copyright (C) Nginx, Inc.
*/
#include <ngx_config.h>
#include <ngx_core.h>
/*
* find the middle queue element if the queue has odd number of elements
* or the first element of the queue's second part otherwise
*/
/*
func：返回链表中心元素
arg: queue是ngx_queue_t容器的指针
*/
ngx_queue_t *
ngx_queue_middle(ngx_queue_t *queue)
{
ngx_queue_t *middle, *next;
//用第一个元素初始化middle
middle = ngx_queue_head(queue);
//如果头尾相等，直接返回当前元素
if (middle == ngx_queue_last(queue)) {
return middle;
}
//用第一个元素初始化next
next = ngx_queue_head(queue);
//快慢指针法
for ( ;; ) {
middle = ngx_queue_next(middle);
next = ngx_queue_next(next);
if (next == ngx_queue_last(queue)) {
return middle;
}
next = ngx_queue_next(next);
if (next == ngx_queue_last(queue)) {
return middle;
}
}
}
/* the stable insertion sort */
/*
func：对链表进行插入排序，比较的方法通过cmp来确定
arg: queue是ngx_queue_t容器的指针，cmp是比较函数的指针
*/
void
ngx_queue_sort(ngx_queue_t *queue,
ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))
{
ngx_queue_t *q, *prev, *next;
q = ngx_queue_head(queue);
//如果只有一个元素直接返回
if (q == ngx_queue_last(queue)) {
return;
}
//利用q遍历链表
for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {
prev = ngx_queue_prev(q);
next = ngx_queue_next(q);
ngx_queue_remove(q);
//常规的插入排序
do {
//满足比较条件则退出当前插入
if (cmp(prev, q) <= 0) {
break;
}
prev = ngx_queue_prev(prev);
} while (prev != ngx_queue_sentinel(queue));
ngx_queue_insert_after(prev, q);
}
}
三、如何使用
- 定义链表类型结构体
typedef struct {
ngx_queue_t qElem;
int num;
} Node
- 自定义比较函数
ngx_int_t cmp(const ngx_queue_t *a, const ngx_queue_t *b){
//先使用ngx_queue_data方法获得链表元素所属结构体的地址
Node* aNode = ngx_queue_data(a, Node, qElem);
Node* bNode = ngx_queue_data(b, Node, qElem);
return aNode->num > bNode->num;
}
- 定义双向链表容器并初始化
ngx_queue_t qContainer;
ngx_queue_init(qContainer);
Node node[5];
for(int i = 0; i < 5; i++){
node[i].num = i;
}
//3 1 0 2 4
ngx_queue_insert_tail(&qContainer, &node[0].qElem);
ngx_queue_insert_head(&qContainer, &node[1].qElem);
ngx_queue_insert_tail(&qContainer, &node[2].qElem);
ngx_queue_insert_head(&qContainer, &node[3].qElem);
ngx_queue_insert_tail(&qContainer, &node[4].qElem);
- 调用排序函数
ngx_queue_sort(&qContainer, cmp);
- 遍历链表获取结果
ngx_queue_t* q;
for (q = ngx_queue_next(&qContainer); q != ngx_queue_sentinel(&qContainer); \
q = ngx_queue_next(q)){
Node* nowNode = ngx_queue_data(q, Node, qElem);
printf("val = %d \n", nowNode->num);//0 1 2 3 4
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
