PHP内核探索：数组与链表

时间：2024-01-10 00:07:20

在C语言中，我们可以自定义各种各样的数据结构，用来把很多数据保存在一个变量里面，但是每种数据结构都有自己的优缺点，PHP内核规模如此庞大，是否已经找到了一些非常棒的解决方法呢？

我们在选择各种数据结构时，往往会考虑我们需要处理的数据规模以及需要的性能。下面让我们简要的看一下看C语言中数组和链表的一些事情。

数组

作者这里用的不是Array，而是Vector，可能指的是C++里的Vector，它与数组几乎是完全一样的，唯一的不同便是可以实现动态存储。本节下文都是用数组一词代替之，请各位注意。数组是内存中一块连续的区域，其每一个元素都具有一个唯一的下标值。

1 int a[3];
2 a[0]=1;
3 a[2]=3;

不仅是整数，其它类型的变量也可以保存在数组中，比如我们前面用到的zend_get_parameters_array_ex()，便把很多zval**类型的变量保存到一个数组里，为了使其正常工作，我们提前向系统申请了相应大小的内存空间。

1 zval ***args = safe_emalloc(ZEND_NUM_ARGS(), sizeof(zval**), 0);

这里我们仍然可以用一个整数来当作下标去数组中取出我们想要的数据，就像var_dump()的实现中通过args[i]来获取参数并把它传递给php_var_dump()函数那样。

使用数组最大的好处便是速度！读写都可以在O(1)内完成，因为它每个元素的大小都是一致的，只要知道下标，便可以瞬间计算出其对应的元素在内存中的位置，从而直接取出或者写入。

链表

链表也是一种经常被使用的一种数据结构。链表中的每一个元素都至少有两个元素，一个指向它的下一个元素，一个用来存放它自己的数据，就像下面定义的那样：

1 typedef struct _namelist namelist;
2 struct
3 {
4     struct _namelist *next;
5     char *name;
6 }_namelist;

我们可以声明一个其类型的元素：

1 static namelist *people;

假设每一个元素都代表一个人，元素中的name属性便是这个人的名字，我们通过这样的语句来得到它：people->name; 第二个属性指向后面的一个元素，那我们便可以这样来访问下一个人的名字：people->next->name, 或者下一个人的下一个人的名字：people->next->next->name,一次类推，直到next的值是NULL，代表结 束。

1 //通过一个循环来遍历这个链表中的所有人～
2 void name_show(namelist *p)
3 {
4     while (p)
5     {
6         printf("Name: %s\n", p->name);
7         p = p->next;
8     }
9 }

链表可以被用来实现FIFO模式，达到先进者先出的目的！

01 static namelist *people = NULL, *last_person = NULL;
02 void name_add(namelist *person)
03 {
04     person->next = NULL;
05     if (!last_person) {
06         /* No one in the list yet */
07         people = last_person = person;
08         return;
09     }
10     /* Append new person to the end of the list */
11     last_person->next = person;
12  
13     /* Update the list tail */
14     last_person = person;
15 }
16 namelist *name_pop(void)
17 {
18     namelist *first_person = people;
19     if (people) {
20         people = people->next;
21     }
22     return first_person;
23 }

这样，我们便可以随意的向这个链表中添加或者删除数据，而不向数组那样，谨慎的考虑是否越界等问题。

上面实现的结构的学名叫做单向链表，也有地方叫单链表，反正是比较简单的意思～。它有一个致命的缺点，就是我们在插入或者读取某条数据的时候，都需 要从这个链表的开始，一个个元素的向下寻找，直到找到这个元素为止。如果链表中的元素比较多，那它很容易成为我们程序中的CPU消耗大户，进而引起性能问 题。为了解决这个问题，先人们发明了双向链表：

1 typedef struct _namelist namelist;
2 struct
3 {
4     namelist *next, *prev;
5     char *name;
6 } _namelist;

改动其实不大，就是在每个元素中都添加了一个prev属性，用来指向它的上一个元素。

01 void name_add(namelist *person)
02 {
03     person->next = NULL;
04     if (!last_person)
05     {
06         /* No one in the list yet */
07         people = last_person = person;
08         person->prev = NULL;
09         return;
10     }
11     /* Append new person to the end of the list */
12     last_person ->next = person;
13     person->prev = last_person;
14  
15     /* Update the list tail */
16     last_person = person;
17 }

单单通过上面的程序你还体会不到它的好处，但是设想一下，如果现在你有这个链表中其中一个元素的地址，并且想把它从链表中删除，那我们该怎么做呢？如果是单向链表的话，我们只能这样做：

01 void name_remove(namelist *person)
02 {
03     namelist *p;
04     if (person == people) {
05         /* Happens to be the first person in the list */
06         people = person->next;
07         if (last_person == person) {
08             /* Also happens to be the last person */
09             last_person = NULL;
10         }
11         return;
12     }
13     /* Search for prior person */
14     p = people;
15     while (p) {
16         if (p->next == person) {
17             /* unlink */
18             p->next = person->next;
19             if (last_person == person) {
20                 /* This was the last element */
21                 last_person = p;
22             }
23             return;
24         }
25         p = p->next;
26     }
27     /* Not found in list */
28 }

现在让我们来看看双向链表是怎样来处理这个问题的：

01 void name_remove(namelist *person)
02 {
03     if (people == person) {
04         people = person->next;
05     }
06     if (last_person == person) {
07         last_person = person->prev;
08     }
09     if (person->prev) {
10  
11         person->prev->next = person->next;
12     }
13     if (person->next) {
14         person->next->prev = person->prev;
15     }
16 }

对元素的遍历查找不见了，取而代之的是一个O(1)的运算，这将极大的提升我们程序的性能。

相关文章