PHP a-t-il des structures de données intégrées ?

Question

je regarde le Manuel PHP, et je ne vois pas de section sur les structures de données que possèdent la plupart des langages, telles que les listes et les ensembles.Suis-je simplement aveugle ou PHP n'a-t-il rien de tel intégré ?

Answer 1

La seule structure de données native en PHP est le tableau.Heureusement, les tableaux sont assez flexibles et peuvent également être utilisés comme tables de hachage.

http://www.php.net/array

Cependant, il existe SPL qui est en quelque sorte un clone de C++ STL.

http://www.php.net/manual/en/book.spl.php

Answer 2

PHP propose des structures de données via l'extension de base Standard PHP Library (SPL), disponible et compilée par défaut dans PHP 5.0.0.

Les structures de données proposées sont disponibles avec PHP 5 >= 5.3.0, et incluent :

Listes doublement liées

Une liste doublement liée (DLL) est une liste de nœuds liés les uns aux autres dans les deux sens.Les opérations de l’itérateur, l’accès aux deux extrémités, l’ajout ou la suppression de nœuds ont un coût de O(1) lorsque la structure sous-jacente est une DLL.Il fournit donc une implémentation décente pour les piles et les files d'attente.

• Classe SplDoublyLinkedList
  • Classe SplStack
  • Classe SplQueue

Des tas

Les tas sont des structures arborescentes qui suivent la propriété du tas :chaque nœud est supérieur ou égal à ses enfants, lorsqu'on le compare à l'aide de la méthode de comparaison implémentée qui est globale au tas.

• Classe SplHeap
  • Classe SplMaxHeap
  • Classe SplMinHeap
• Classe SplPriorityQueue

Tableaux

Les tableaux sont des structures qui stockent les données de manière continue, accessibles via des index.Ne les confondez pas avec les tableaux PHP :Les tableaux PHP sont en fait implémentés sous forme de tables de hachage ordonnées.

• Classe SplFixedArray

Carte

Une carte est une structure de données contenant des paires clé-valeur.Les tableaux PHP peuvent être considérés comme des cartes d'entiers/chaînes vers des valeurs.SPL fournit une carte des objets aux données.Cette carte peut également être utilisée comme ensemble d'objets.

• Classe SplObjectStorage

Source: http://php.net/manual/en/spl.datastructures.php

Answer 3

Le tableau associatif peut être utilisé pour la plupart des structures de données de base, table de hachage, file d'attente, pile.Mais si vous voulez quelque chose comme un arbre ou un tas, je ne pense pas qu'ils existent par défaut, mais je suis sûr qu'il existe des bibliothèques gratuites n'importe où.

Pour qu'un tableau émule une pile, utilisez array_push() ajouter et array_pop() décoller

Pour qu'un tableau émule une file d'attente, utilisez array_push() mettre en file d'attente et array_shift() sortir de la file d'attente

Un tableau associatif est un hachage par défaut.En PHP, ils sont autorisés à avoir des chaînes comme index, donc cela fonctionne comme prévu :

$array['key'] = 'value';

Enfin, vous pouvez en quelque sorte émuler un arbre binaire avec un tableau susceptible de gaspiller de l'espace.C'est utile si vous savez que vous allez avoir un petit arbre.En utilisant un tableau linéaire, vous dites que pour tout index (i), vous placez son enfant gauche à l'index (2i+1) et son enfant droit à l'index (2i+2).

Toutes ces méthodes sont bien couvertes dans Cet article sur la façon de faire en sorte que les tableaux JavaScript émulent des structures de données de niveau supérieur.

Answer 4

Bien que cette question date de 8 ans, je poste une réponse car PHP 7 introduit une extension appelée ds fournir des structures de données spécialisées comme alternative au tableau.

Le ds,

• utilise le Ds\ espace de noms.
• dispose de 3 interfaces à savoir,Collection, Sequence et Hashable
• a 8 classes à savoir, Vector, Deque,Queue, PriorityQueue, Map, Set, Stack, et Pair

Pour plus d'informations, consultez le Manuel et aussi Ce billet de blog contient des informations impressionnantes, notamment des points de repère.

Answer 5

PHP possède des tableaux qui sont en fait des tableaux associatifs et peuvent également être utilisés comme ensembles.Comme de nombreux langages interprétés, PHP propose tout cela sous un seul capot au lieu de fournir différents types de données explicites.

Par exemple.

$lst = array(1, 2, 3);
$hsh = array(1 => "This", 2 => "is a", 3 => "test");

/Modifier:Jetez également un oeil dans le manuel.

Answer 6

PHP tableau sert également de liste et de dictionnaire.

$myArray = array("Apples", "Oranges", "Pears");
$myScalar = $myArray[0] // == "Apples"

Ou pour l'utiliser comme tableau associatif :

$myArray = array("a"=>"Apples", "b"=>"Oranges", "c"=>"Pears");
$myScalar = $myArray["a"] // == "Apples"

Answer 7

Je pense que vous voudrez peut-être être un peu plus précis, quand vous parlez de structures de données, mon esprit va dans plusieurs directions...

Tableaux - Ils sont certainement bien documentés et disponibles.(http://us.php.net/manual/en/book.array.php)

Données SQL : dépend de la base de données que vous utilisez, mais la plupart sont disponibles.(http://us.php.net/manual/en/book.mysql.php)

POO - En fonction de la version, des objets peuvent être conçus et implémentés.(http://us.php.net/manual/en/langue.oop.php) J'ai dû rechercher POO pour trouver cela sur le site php.

J'espère que cela aide, désolé si ce n'est pas le cas.

Answer 8

Bien sûr, PHP a des structures de données.Le tableau en php est incroyablement flexible.Quelques exemples:

$foo = array(
  'bar' => array(1,'two',3),
  'baz' => explode(" ", "Some nice words")
);

Ensuite, vous disposez d'une pléthore absolue de fonctions de tableau disponibles pour mapper/filtrer/parcourir/etc les structures, ou convertir, retourner, inverser, etc.

Answer 9

Vous pouvez toujours créer le vôtre si vous ne pensez pas que PHP inclut un type spécifique de structure de données.Par exemple, voici une simple structure de données Set soutenue par un Array.

Ensemble de tableaux : https://github.com/abelperez/collections/blob/master/ArraySet.php

class ArraySet
{
    /** Elements in this set */
    private $elements;

    /** the number of elements in this set */
    private $size = 0;

    /**
     * Constructs this set.
     */ 
    public function ArraySet() {
        $this->elements = array();
    }

    /**
     * Adds the specified element to this set if 
     * it is not already present.
     * 
     * @param any $element
     *
     * @returns true if the specified element was
     * added to this set.
     */
    public function add($element) {
        if (! in_array($element, $this->elements)) {
            $this->elements[] = $element;
            $this->size++;
            return true;
        }
        return false;
    }

    /**
     * Adds all of the elements in the specified 
     * collection to this set if they're not already present.
     * 
     * @param array $collection
     * 
     * @returns true if any of the elements in the
     * specified collection where added to this set. 
     */ 
    public function addAll($collection) {
        $changed = false;
        foreach ($collection as $element) {
            if ($this->add($element)) {
                $changed = true;
            }
        }
        return $changed;
    }

    /**
     * Removes all the elements from this set.
     */ 
    public function clear() {
        $this->elements = array();
        $this->size = 0;
    }

    /**
     * Checks if this set contains the specified element. 
     * 
     * @param any $element
     *
     * @returns true if this set contains the specified
     * element.
     */ 
    public function contains($element) {
        return in_array($element, $this->elements);
    }

    /**
     * Checks if this set contains all the specified 
     * element.
     * 
     * @param array $collection
     * 
     * @returns true if this set contains all the specified
     * element. 
     */ 
    public function containsAll($collection) {
        foreach ($collection as $element) {
            if (! in_array($element, $this->elements)) {
                return false;
            }
        }
        return true;
    }

    /**
     * Checks if this set contains elements.
     * 
     * @returns true if this set contains no elements. 
     */ 
    public function isEmpty() {
        return count($this->elements) <= 0;
    }

    /**
     * Get's an iterator over the elements in this set.
     * 
     * @returns an iterator over the elements in this set.
     */ 
    public function iterator() {
        return new SimpleIterator($this->elements);
    }

    /**
     * Removes the specified element from this set.
     * 
     * @param any $element
     *
     * @returns true if the specified element is removed.
     */ 
    public function remove($element) {
        if (! in_array($element, $this->elements)) return false;

        foreach ($this->elements as $k => $v) {
            if ($element == $v) {
                unset($this->elements[$k]);
                $this->size--;
                return true;
            }
        }       
    }

    /**
     * Removes all the specified elements from this set.
     * 
     * @param array $collection
     *
     * @returns true if all the specified elemensts
     * are removed from this set. 
     */ 
    public function removeAll($collection) {
        $changed = false;
        foreach ($collection as $element) {
            if ($this->remove($element)) {
                $changed = true;
            } 
        }
        return $changed;
    }

    /**
     * Retains the elements in this set that are
     * in the specified collection.  If the specified
     * collection is also a set, this method effectively
     * modifies this set into the intersection of 
     * this set and the specified collection.
     * 
     * @param array $collection
     *
     * @returns true if this set changed as a result
     * of the specified collection.
     */ 
    public function retainAll($collection) {
        $changed = false;
        foreach ($this->elements as $k => $v) {
            if (! in_array($v, $collection)) {
                unset($this->elements[$k]);
                $this->size--;
                $changed = true;
            }
        }
        return $changed;
    }

    /**
     * Returns the number of elements in this set.
     * 
     * @returns the number of elements in this set.
     */ 
    public function size() {
        return $this->size; 
    }

    /**
     * Returns an array that contains all the 
     * elements in this set.
     * 
     * @returns an array that contains all the 
     * elements in this set.
     */ 
    public function toArray() {
        $elements = $this->elements;
        return $elements;   
    }
}

Answer 10

PHP peut aussi avoir un tableau de tableaux qui est appelé « tableau multidimensionnel » ou « matrice ».Vous pouvez avoir des tableaux à 2 dimensions, des tableaux à 3 dimensions, etc.

Answer 11

Pour le besoin obligatoire de structures de données, veuillez rechercher le SPL(Extensions PHP).Ils ont des structures de données comme un tas, une liste chaînée, ..etc...

PHP n'a pas la liste et définit exactement les structures de données.mais ils peuvent être réalisés par un tableau (avec n dimensions), qui fournit plusieurs données avec un seul cluster

$variable = array(
  'one' => array(1,'char',3),
  'two' => explode("single", "Multiple strings"),
  'three' => all(9,'nine',"nine")
);

Ils ne sont pas exactement comme une liste ou un ensemble.Mais un tableau peut remplacer cela.Pas besoin donc de chercher d’autres structures de données.

Answer 12

Oui.

<?php
$my_array = array("Bird","Cat","Cow");

list($a, $b, $c) = $my_array;
echo "I have several animals, a $a, a $b and a $c.";
?>

http://www.w3schools.com/php/func_array_list.asp

Answer 13

Les langages C permettront de créer une structure puis de la remplir comme un tampon de chaîne (car/octet).Une fois rempli, le code accède au tampon via les membres de la structure.C'est vraiment sympa d'analyser des fichiers structurés (base de données, image, etc.) de cette façon.Je ne pense pas que vous puissiez faire cela avec les structures PHP - ou est-ce que je me trompe (j'espère).

Ok - eh bien PHP a unpack et pack - fonctionnellement identique, mais pas aussi élégant.