Maitriser les structures de données PHP 102 - Forum Paris 2012

Maitriser les structures de données PHP 102
Patrick ALLAERT

Forum PHP 2012 Paris, France

Patrick ALLAERT
● Fondateur de Libereco Technologies
● Travailles avec PHP/Linux depuis '98
● Core développeur eZ Publish
● Auteur de l'extension PHP APM
● @patrick_allaert
● patrickallaert@php.net
● http://github.com/patrickallaert/
● http://patrickallaert.blogspot.com/

Structures de données PHP natives
●
NULL (IS_NULL)
●
Booléens (IS_BOOL)
●
Entiers (IS_LONG)
●
Nombres à virgule flottante
(IS_DOUBLE)
●
Chaine de caractères (IS_STRING)
●
Tableaux (IS_ARRAY,
IS_CONSTANT_ARRAY)
●
Objets (IS_OBJECT)
●
Ressources (IS_RESOURCE)
●
Callable (IS_CALLABLE)

Les structures de données sur Wikipedia
●
2-3-4 tree ●
Bit field ●
Directed acyclic ● Hashed array tree Map/Associative
● ●
Rapidly-exploring ●
Suffix tree
graph array/Dictionary random tree Symbol table
2-3 heap
●
● ● Bitmap ● Hash list
●
Directed graph ●
Matrix ●
Record (also called ● Syntax tree
●
2-3 tree BK-tree
●

Disjoint-set
● Hash table tuple or struct) Tagged union (variant
Metric tree
●
● ●
●
AA tree Bloom filter record, discriminated
●
Distributed hash
● Hash tree ●
Red-black tree
● ●
Minimax tree union, disjoint union)
●
Abstract syntax tree ●
Boolean table ● Hash trie ●
Min/max kd-tree
●
Rope ●
Tango tree
●
(a,b)-tree Double Routing table
● Bounding interval ●
M-tree
●
Ternary heap
Heap
●
● ●
●
Adaptive k-d tree hierarchy ●
Doubly connected ●
R-tree ● Ternary search tree
Heightmap
●
Multigraph
●
Adjacency list ● B sharp tree edge list ●
●
R* tree ● Threaded binary tree
●
Multimap
●
Adjacency matrix ●
BSP tree
●
Doubly linked list ● Hilbert R-tree ●
R+ tree
● Top tree
●
Multiset Treap
●
AF-heap ●
Dynamic array ● Hypergraph Scapegoat tree
●

B-tree
●
● ●
Octree ●
Tree
Alternating decision Enfilade Scene graph
Iliffe vector
● ●

B*-tree
● ●

tree
● ●
Pagoda ● Trees
●
Enumerated type Segment tree
Image
●
●
B+ tree ● ●
Pairing heap ●
Trie
● And-inverter graph Expectiminimax tree Self-balancing
●
T-tree
●

Implicit kd-tree Parallel array ●

●
And–or tree
● B-trie ●
Exponential tree
● ●

binary search tree ●
UB-tree
Bx-tree Interval tree
●
Parse tree
●
Array ●
●
Fenwick tree
●
●
Self-organizing list ●
Union
●
Plain old data
●
AVL tree ● Cartesian tree ●
Fibonacci heap ●
Int ●
Set Unrolled linked list
structure
●

●
Beap ● Char ●
Finger tree ● Judy array ●
Prefix hash tree
●
Skew heap ●
Van Emde Boas tree

Skip list Variable-length array
Bidirectional map Circular buffer Float
●
●
Kdb tree
● ●
Priority queue
●
● ●
● VList
Bin Compressed suffix FM-index
● ●
Soft heap
Propositional
●
Kd-tree
● ●
● ● VP-tree
●
Binary decision array Fusion tree
● directed acyclic ●
Sorted array
Koorde ● Weight-balanced tree
diagram Gap buffer
●
graph Spaghetti stack
● Container ● ●
● Winged edge
●
Binary heap Generalised suffix
● Leftist heap ●
Quad-edge Sparse array
Control table
●
●
●
● X-fast trie
●
Binary search tree tree ● Lightmap ●
Quadtree ●
Sparse matrix Xor linked list
Cover tree
●
●

Binary tree
●
Graph ●
Queap Splay tree X-tree
●
● Ctrie
● Linear octree ● ●

Binomial heap
●
Graph-structured ●
Queue SPQR-tree
●
Y-fast trie
Link/cut tree
● ●

Dancing tree
●
●
stack Radix tree ●
Zero suppressed
Stack
●
●
Bit array ●

● D-ary heap ●
Hash ●
Linked list Randomized binary
decision diagram
String
●
●
Bitboard ●
● Zipper
● Decision tree ●
Hash array mapped ● Lookup table search tree
trie
●
Suffix array ●
Z-order
● Deque
●
Range tree

Jeu:
Pouvez-vous reconnaitre ces
structures/concepts?

Array: Le mensonge PHP
Les “Arrays” PHP ne sont pas de vrais tableaux!

Les “Arrays” PHP ne sont pas de vrais tableaux!
Un tableau ressemble typiquement à:

0 1 2 3 4 5

Data Data Data Data Data Data

Les “Arrays” PHP peuvent être modifiés dynamiquement et
être itérés dans différentes directions (reset(), next(), prev(),
end()), et ce exclusivement avec des operations en O(1).

Les “Arrays” PHP peuvent être modifiés dynamiquement et
être itérés dans différentes directions (reset(), next(), prev(),
end()), et ce exclusivement avec des operations en O(1).
Imaginons une liste doublement chainée:

Head Tail

Data Data Data Data Data

Permet d'implémenter: Liste, Deque, File et Tas

Les éléments d'un“Array” PHP peuvent à tout
moment être accédés au moyen d'une clé (index).

Les éléments d'un“Array” PHP peuvent à tout
moment être accédés au moyen d'une clé (index).
Voyons avec une table de hachage:
Head Bucket pointers array Tail
0 1 2 3 4 5 ... nTableSize -1
Bucket * Bucket * Bucket * Bucket * Bucket * Bucket * Bucket *

Bucket Bucket Bucket Bucket Bucket

Data Data Data Data Data

http://php.net/manual/fr/language.types.array.php:

“Ce type est optimisé pour différentes
utilisations ; il peut être considéré comme
un tableau, une liste, une table de
hashage, un dictionnaire, une collection,
une pile, une file d'attente et
probablement plus.”

Optimisé pour tous les cas ≈ optimisé pour aucun cas!

● En C: 100 000 entiers (long sur 64bits => 8 octets)
peuvent être stockés moyennant 0.76 Mo.
● En PHP: cela prend ≅ 13.97 Mo!
● Une variable PHP (contenant un entier par
exemple) prend 48 octets.
● L'overhead des buckets pour chacune des entrées
d'un “array” est approximativement: 96 octets.
● Plus de détails:
http://nikic.github.com/2011/12/12/How-big-are-PHP-arrays-really-Hint-BIG.html

Structs (ou records, tuples,...)

Structs (ou records, tuples,...)
● Une struct est une valeur contenant
habituellement plusieurs autres valeurs et qui sont
accédées moyennant un nom.
● Exemple:
Person => firstName / lastName
ComplexNumber => realPart / imaginaryPart

Structs – Avec un array
$person = array(
"firstName" => "Patrick",
"lastName" => "Allaert"
);

Structs – Avec une classe
$person = new PersonStruct(
"Patrick", "Allaert"
);

(Implémentation)
class PersonStruct
{
public $firstName;
public $lastName;

public function __construct($firstName, $lastName)
{
$this->firstName = $firstName;
$this->lastName = $lastName;
}
}

(Implémentation)
class PersonStruct
{
public $firstName;
public $lastName;

public function __construct($firstName, $lastName)
{
$this->firstName = $firstName;
$this->lastName = $lastName;
}

public function __set($key, $value)
{
// a. Ne rien faire
// b. trigger_error()
// c. Lancer une exception
}
}

Structs – Avantages et
inconvénients
Array Class
+ Utilise moins de mémoire - Utilise plus de mémoire (PHP <
(PHP < 5.4) 5.4)
- Utilise plus de mémoire (PHP = + Utilise moins de mémoire
5.4) (PHP = 5.4)
- Pas de type hinting + Type hinting possible
- Structure flexible + Structure rigide
+|- Moins OO +|- Plus OO

(vrai) Tableaux
● Un tableau est une collection de taille fixe dont les
éléments sont tous identifiés par un index
numérique.

(vrai) Tableaux
● Un tableau est une collection de taille fixe dont les
éléments sont tous identifiés par un index
numérique.
0 1 2 3 4 5


(vrai) Tableaux – Avec
SplFixedArray
$array = new SplFixedArray(3);
$array[0] = 1; // ou $array->offsetSet()
$array[0]; // donne 1

(vrai) Tableaux – Avantages et
inconvénients
Array SplFixedArray
- Utilise plus de mémoire + Utilise moins de mémoire

Files
● Une pile est une collection ordonnée respectant
l'ordre First In, First Out (FIFO).
● Les éléments sont insérés d'un côté et enlevés de
l'autre.

Files
l'ordre First In, First Out (FIFO).
● Les éléments sont insérés d'un côté et enlevés de
l'autre.

Data

Dequeue
Enqueue

Data

Files – Avec un array
$queue = array();
$queue[] = 1; // ou array_push()
array_shift($queue); // donne 1

Files – Avec SplQueue
$queue = new SplQueue();
$queue[] = 1; // ou $queue->enqueue()
$queue->dequeue(); // donne 1

Piles
l'ordre Last In, First Out (LIFO).
● Les éléments sont insérés et enlevés du même
côté.

Piles
l'ordre Last In, First Out (LIFO).
● Les éléments sont insérés et enlevés du même
côté.

Data

Push
Pop

Data

Piles – Avec un array
$stack = array();
$stack[] = 1; // ou array_push()
array_pop($stack); // donne 3

Piles – Avec SplStack
$stack = new SplStack();
$stack[] = 1; // ou $stack->push()
$stack->pop(); // donne 3

Files/Piles – Avantages et
inconvénients
Array SplQueue / SplStack
- Utilise plus de mémoire + Utilise moins de mémoire
(overhead / entrée: 96 octets) (overhead / entrée: 48 octets)
- Pas de type hinting + Type hinting possible

Ensembles

Geeks Nerds
Personnes ayant
une opinion très
tranchée sur la
différence
entre geeks et
nerds

Ensembles
● Un ensemble est une collection sans ordre
spécifique particulièrement adapté pour tester
l'appartenance d'une valeur à une collection ou
pour réaliser une opération
d'union/d'intersection/de complément entre eux.

Ensembles
● Un ensemble est une collection sans ordre
spécifique particulièrement adapté pour tester
l'appartenance d'une valeur à une collection ou
pour réaliser une opération
d'union/d'intersection/de complément entre eux.
Data

Data
Data

Data
Data

Ensembles – Avec un array
$set = array();

// Adding elements to a set
$set[] = 1;
$set[] = 2;
$set[] = 3;

// Checking presence in a set
in_array(2, $set); // true
in_array(5, $set); // false

array_merge($set1, $set2); // union
array_intersect($set1, $set2); // intersection
array_diff($set1, $set2); // complement

Ensembles – Avec un array
$set = array();

$set[] = 1;
$set[] = 2;
$set[] = 3; True
// Checking presence in a set performance
in_array(2, $set); // true
in_array(5, $set); // false
killers!
array_merge($set1, $set2); // union
array_intersect($set1, $set2); // intersection
array_diff($set1, $set2); // complement

Ensembles – Abus
if ($value === "val1" || $value === "val2" || $value ===
"val3")))
{
// ...
}

Ensembles – Abus
if (in_array($value, array("val1", "val2", "val3")))
{
// ...
}

Ensembles – Abus
switch ($value)
{
case "val1":
case "val2":
case "val3":
// ...
}

Ensembles – Avec un array (types
simples)
$set = array();

$set[1] = true; // Any dummy value
$set[2] = true; // is good but NULL!
$set[3] = true;

isset($set[2]); // true
isset($set[5]); // false

$set1 + $set2; // union
array_intersect_key($set1, $set2); // intersection
array_diff_key($set1, $set2); // complement

Ensembles – Avec un array (types
simples)
$set = array();

$set[1] = true; // Any dummy value
$set[2] = true; // is good but NULL!
$set[3] = true;

isset($set[2]); // true
isset($set[5]); // false

● Attention : les clés d'un array PHP ne peuvent être
que des entiers ou des strings !

Ensembles – Avec un array (objets)
$set = array();

$set[spl_object_hash($object1)] = $object1;

isset($set[spl_object_hash($object2)]); // true
isset($set[spl_object_hash($object5)]); // false


Ensembles – Avec un array (objets)
$set = array();

$set[spl_object_hash($object1)] = $object1; Store a
$set[spl_object_hash($object2)] = $object2; reference of
$set[spl_object_hash($object3)] = $object3; the object!
isset($set[spl_object_hash($object2)]); // true
isset($set[spl_object_hash($object5)]); // false


Ensembles – Avec
SplObjectStorage (objets)
$set = new SplObjectStorage();

$set->attach($object1); // ou $set[$object1] = null;

isset($set[$object2]); // true
isset($set[$object2]); // false

$set1->addAll($set2); // union
$set1->removeAllExcept($set2); // intersection
$set1->removeAll($set2); // complement

Ensembles – Avec QuickHash (int)
$set = new QuickHashIntSet(64,
QuickHashIntSet::CHECK_FOR_DUPES);

$set->add(1);
$set->add(2);
$set->add(3);

$set->exists(2); // true
$set->exists(5); // false

// Soonish: isset($set[2]);
● Pas (encore?) d'opérations d'union/d'intersection/de
complément.
● Fonctionnalités intéressantes : (loadFrom|saveTo)(String|File)

Ensembles – Avec des bitsets
define("E_ERROR", 1); // ou 1<<0
define("E_WARNING", 2); // ou 1<<1
define("E_PARSE", 4); // ou 1<<2
define("E_NOTICE", 8); // ou 1<<3

$set = 0;
$set |= E_ERROR;
$set |= E_WARNING;
$set |= E_PARSE;

$set & E_ERROR; // true
$set & E_NOTICE; // false

$set1 | $set2; // union
$set1 & $set2; // intersection
$set1 ^ $set2; // complement

(exemple)
Au lieu de:
function remove($path, $files = true, $directories = true, $links = true,
$executable = true)
{
if (!$files && is_file($path))
return false;

if (!$directories && is_dir($path))
return false;

if (!$links && is_link($path))
return false;

if (!$executable && is_executable($path))
return false;

// ...
}

remove("/tmp/removeMe", true, false, true, false); // WTF ?!

(exemple)
Essayer:
define("REMOVE_FILES", 1 << 0);
define("REMOVE_DIRS", 1 << 1);
define("REMOVE_LINKS", 1 << 2);
define("REMOVE_EXEC", 1 << 3);
define("REMOVE_ALL", ~0); // Setting all bits

function remove($path, $options = REMOVE_ALL)
{
if (~$options & REMOVE_FILES && is_file($path))
return false;

if (~$options & REMOVE_DIRS && is_dir($path))
return false;

if (~$options & REMOVE_LINKS && is_link($path))
return false;

if (~$options & REMOVE_EXEC && is_executable($path))
return false;

// ...
}

remove("/tmp/removeMe", REMOVE_FILES | REMOVE_LINKS); // Much better :)

Ensembles: Conclusions
● Utilisez la clé et non la valeur lorsque vous utilisez
un array PHP.
● Utilisez QuickHash pour des ensembles d'entiers si
possible.
● Utilisez SplObjectStorage dès que vous travaillez
avec des objecs.
● N'utilisez par array_unique() / in_array() /
array_search() lorsque vous avez besoin d'un
ensemble !

Maps
● Une map est une collection de paires clé/valeur où
chaque clé est unique.

Maps – Avec un array
$map = array();
$map["ONE"] = 1;
$map["TWO"] = 2;
$map["THREE"] = 3;

// Merging maps:
array_merge($map1, $map2); // SLOW!
$map2 + $map1; // Fast :)
● N'utilisez pas array_merge() sur des maps.

Maps multi-clés – Avec un array
$map = array();
$map["ONE"] = 1;
$map["UN"] =& $map["ONE"];
$map["UNO"] =& $map["ONE"];
$map["TWO"] = 2;
$map["DEUX"] =& $map["TWO"];
$map["DUE"] =& $map["TWO"];

$map["UNO"] = "once";
$map["DEUX"] = "twice";

var_dump($map);
/*
array(6) {
["ONE"] => &string(4) "once"
["UN"] => &string(4) "once"
["UNO"] => &string(4) "once"
["TWO"] => &string(5) "twice"
["DEUX"] => &string(5) "twice"
["DUE"] => &string(5) "twice"
}
*/

Tas (Heap)
● Un tas est une structure basée sur un arbre dans
lequel les éléments sont ordonnés avec la clé la
plus grande (ou petite) au sommet et les plus
petites (ou grandes) comme feuilles.

Tas (Heap) – Avec un array
$heap = array();
$heap[] = 3;
sort($heap);
$heap[] = 1;
sort($heap);
$heap[] = 2;
sort($heap);

Tas (Heap) – Avec
Spl(Min|Max)Heap
$heap = new SplMinHeap;
$heap->insert(3);
$heap->insert(1);
$heap->insert(2);

Tas (Heap): Conclusions
● BEAUCOUP plus rapide que de devoir réordonner un
array à chaque insertion.
● Si vous n'avez pas besoin qu'une collection soit
ordonnée à chaque étape et que vous pouvez insérer
toutes les données en un coup et ensuite utilisez
sort(). Dans ce cas l'array est une bien meilleure
approche.
● SplPriorityQueue est très similaire, considérez qu'il
s'agit de la même chose que SplHeap mais où le tri est
fait sur la clé et non la valeur.

Filtre de Bloom
● Un filtre de Bloom est une structure probabiliste
efficace en terme d'espace permettant de tester
l'appartenance d'un élément à un ensemble.
● Les faux-positifs sont possibles, mais les faux-
négatifs ne le sont jamais !
● Package PECL : bloomy

Filtre de Bloom – Avec bloomy
// BloomFilter::__construct(int capacity [, double
error_rate [, int random_seed ] ])
$bloomFilter = new BloomFilter(10000, 0.001);

$bloomFilter->add("An element");

$bloomFilter->has("An element"); // true for sure
$bloomFilter->has("Foo"); // false, most probably

Autres projets apparentés
● SPL Types: Différents types implémentés comme
objet: SplInt, SplFloat, SplEnum, SplBool et
SplString http://pecl.php.net/package/SPL_Types

● Judy: Implémentation de Sparse dynamic arrays
http://pecl.php.net/package/Judy

● Judy: Implémentation de Sparse dynamic arrays
http://pecl.php.net/package/Judy
● Weakref: Implementation de « pointeurs faibles »
(Weak reference).
Permet de référencer un objet sans pour autant
empêcher le GC de pouvoir récupérer cet objet.

Conclusions
● Utilisez des structures de données appropriées.
Cela vous permet de garder un code propre et
optimal.

Conclusions
optimal.
● Pensez à la complexité en termes de temps et
d'espaces impliquée par vos algorithmes.

Conclusions
optimal.
● Pensez à la complexité en termes de temps et
d'espaces impliquée par vos algorithmes.
● Nommez vos variables de manière appropriée :
Utilisez « Map », « Set », « List », « Queue »,... afin de
décrire leur rôle et utilisation.

Merci
● N'oubliez pas de donner votre évaluation sur cette session sur :
http://joind.in/6446

Crédits Photos
● Tuned car:
http://www.flickr.com/photos/gioxxswall/5783867752
● London Eye Structure:
http://www.flickr.com/photos/photographygal123/4883546484
● Cigarette:
http://www.flickr.com/photos/superfantastic/166215927
● Heap structure:
http://en.wikipedia.org/wiki/File:Max-Heap.svg
● Drawers:
http://www.flickr.com/photos/jamesclay/2312912612
● Stones stack:
http://www.flickr.com/photos/silent_e/2282729987
● Tree:
http://www.flickr.com/photos/drewbandy/6002204996

Maitriser les structures de données PHP 102 - Forum Paris 2012

Recomendados

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (20)

Maitriser les structures de données PHP 102 - Forum Paris 2012