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 lextension 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 PHPLes “Arrays” PHP ne sont pas de vrais tableaux!

Array: Le mensonge PHPLes “Arrays” PHP ne sont pas de vrais tableaux!Un tableau ressemble typiquement à: 0 1 2 3 4 5 Data Data Data Data Data Data

Array: Le mensonge PHPLes “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).

Array: Le mensonge PHPLes “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 DataPermet dimplémenter: Liste, Deque, File et Tas

Array: Le mensonge PHPLes éléments dun“Array” PHP peuvent à toutmoment être accédés au moyen dune clé (index).

Array: Le mensonge PHPLes éléments dun“Array” PHP peuvent à toutmoment être accédés au moyen dune 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

Array: Le mensonge PHPhttp://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 dattente et probablement plus.”

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

Array: Le mensonge PHP● 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.● Loverhead des buckets pour chacune des entrées dun “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

Structures de données

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");

Structs – Avec une classe (Implémentation)class PersonStruct{ public $firstName; public $lastName; public function __construct($firstName, $lastName) { $this->firstName = $firstName; $this->lastName = $lastName; }}

Structs – Avec une classe (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émoire5.4) (PHP = 5.4)- Pas de type hinting + Type hinting possible- Structure flexible + Structure rigide+|- Moins OO +|- Plus OO

(vrai) Arrays

(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 Data Data Data Data Data Data

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

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

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

Files● Une pile est une collection ordonnée respectant lordre First In, First Out (FIFO).● Les éléments sont insérés dun côté et enlevés de lautre. Data Dequeue Data Data Data Data Data Data Enqueue Data

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

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

Piles● Une pile est une collection ordonnée respectant lordre Last In, First Out (LIFO).● Les éléments sont insérés et enlevés du même côté.

Piles● Une pile est une collection ordonnée respectant lordre Last In, First Out (LIFO).● Les éléments sont insérés et enlevés du même côté. Data Push Data Data Data Data Data Data Pop Data

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

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

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+|- Moins OO +|- Plus OO

EnsemblesGeeks 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 lappartenance dune valeur à une collection ou pour réaliser une opération dunion/dintersection/de complément entre eux.

Ensembles● Un ensemble est une collection sans ordre spécifique particulièrement adapté pour tester lappartenance dune valeur à une collection ou pour réaliser une opération dunion/dintersection/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 setin_array(2, $set); // truein_array(5, $set); // falsearray_merge($set1, $set2); // unionarray_intersect($set1, $set2); // intersectionarray_diff($set1, $set2); // complement

Ensembles – Avec un array$set = array();// Adding elements to a set$set[] = 1;$set[] = 2;$set[] = 3; True// Checking presence in a set performancein_array(2, $set); // truein_array(5, $set); // false killers!array_merge($set1, $set2); // unionarray_intersect($set1, $set2); // intersectionarray_diff($set1, $set2); // complement

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

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

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

Ensembles – Avec un array (types simples)$set = array();// Adding elements to a set$set[1] = true; // Any dummy value$set[2] = true; // is good but NULL!$set[3] = true;// Checking presence in a setisset($set[2]); // trueisset($set[5]); // false$set1 + $set2; // unionarray_intersect_key($set1, $set2); // intersectionarray_diff_key($set1, $set2); // complement

Ensembles – Avec un array (types simples)$set = array();// Adding elements to a set$set[1] = true; // Any dummy value$set[2] = true; // is good but NULL!$set[3] = true;// Checking presence in a setisset($set[2]); // trueisset($set[5]); // false$set1 + $set2; // unionarray_intersect_key($set1, $set2); // intersectionarray_diff_key($set1, $set2); // complement● Attention : les clés dun array PHP ne peuvent être que des entiers ou des strings !

Ensembles – Avec un array (objets)$set = array();// Adding elements to a set$set[spl_object_hash($object1)] = $object1;$set[spl_object_hash($object2)] = $object2;$set[spl_object_hash($object3)] = $object3;// Checking presence in a setisset($set[spl_object_hash($object2)]); // trueisset($set[spl_object_hash($object5)]); // false$set1 + $set2; // unionarray_intersect_key($set1, $set2); // intersectionarray_diff_key($set1, $set2); // complement

Ensembles – Avec un array (objets)$set = array();// Adding elements to a set$set[spl_object_hash($object1)] = $object1; Store a$set[spl_object_hash($object2)] = $object2; reference of$set[spl_object_hash($object3)] = $object3; the object!// Checking presence in a setisset($set[spl_object_hash($object2)]); // trueisset($set[spl_object_hash($object5)]); // false$set1 + $set2; // unionarray_intersect_key($set1, $set2); // intersectionarray_diff_key($set1, $set2); // complement

Ensembles – Avec SplObjectStorage (objets)$set = new SplObjectStorage();// Adding elements to a set$set->attach($object1); // ou $set[$object1] = null;$set->attach($object2); // ou $set[$object2] = null;$set->attach($object3); // ou $set[$object3] = null;// Checking presence in a setisset($set[$object2]); // trueisset($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);// Adding elements to a set$set->add(1);$set->add(2);$set->add(3);// Checking presence in a set$set->exists(2); // true$set->exists(5); // false// Soonish: isset($set[2]);● Pas (encore?) dopérations dunion/dintersection/de complément.● Fonctionnalités intéressantes : (loadFrom|saveTo)(String|File)

Ensembles – Avec des bitsetsdefine("E_ERROR", 1); // ou 1<<0define("E_WARNING", 2); // ou 1<<1define("E_PARSE", 4); // ou 1<<2define("E_NOTICE", 8); // ou 1<<3// Adding elements to a set$set = 0;$set |= E_ERROR;$set |= E_WARNING;$set |= E_PARSE;// Checking presence in a set$set & E_ERROR; // true$set & E_NOTICE; // false$set1 | $set2; // union$set1 & $set2; // intersection$set1 ^ $set2; // complement

Ensembles – Avec des bitsets (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 ?!

Ensembles – Avec des bitsets (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 bitsfunction 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 dentiers si possible.● Utilisez SplObjectStorage dès que vous travaillez avec des objecs.● Nutilisez par array_unique() / in_array() / array_search() lorsque vous avez besoin dun 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 :)● Nutilisez 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 navez pas besoin quune 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 larray est une bien meilleure approche.● SplPriorityQueue est très similaire, considérez quil sagit 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 despace permettant de tester lappartenance dun é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 [, doubleerror_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

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

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● 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● Utilisez des structures de données appropriées. Cela vous permet de garder un code propre et optimal.● Pensez à la complexité en termes de temps et despaces impliquée par vos algorithmes.

Conclusions● Utilisez des structures de données appropriées. Cela vous permet de garder un code propre et optimal.● Pensez à la complexité en termes de temps et despaces 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● Noubliez pas de donner votre évaluation sur cette session sur : http://joind.in/6446

Questions?

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

by Patrick Allaert on Jun 06, 2012

Accessibility

Categories

Upload Details

Usage Rights

2 Embeds 191

Statistics

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

http://news.humancoders.com	189
http://lanyrd.com	2