¿PHP tiene estructuras de datos integradas?

Question

estoy mirando el Manual PHP, y no veo una sección sobre estructuras de datos que tienen la mayoría de los lenguajes, como listas y conjuntos.¿Estoy simplemente ciego o PHP no tiene nada como esto integrado?

Answer 1

La única estructura de datos nativa en PHP es la matriz.Afortunadamente, las matrices son bastante flexibles y también pueden usarse como tablas hash.

http://www.php.net/array

Sin embargo, existe SPL que es una especie de clon de C++ STL.

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

Answer 2

PHP ofrece estructuras de datos a través de la extensión básica Biblioteca PHP estándar (SPL), que está disponible y compilada de forma predeterminada en PHP 5.0.0.

Las estructuras de datos ofrecidas están disponibles con PHP 5 >= 5.3.0, e incluyen:

Listas doblemente enlazadas

Una lista doblemente enlazada (DLL) es una lista de nodos enlazados en ambas direcciones entre sí.Las operaciones del iterador, acceso a ambos extremos, adición o eliminación de nodos tienen un costo de O(1) cuando la estructura subyacente es una DLL.Por tanto, proporciona una implementación decente para pilas y colas.

• Clase SplDoublyLinkedList
  • Clase SplStack
  • Clase SplQueue

Muchísimo

Los montones son estructuras en forma de árbol que siguen la propiedad del montón:cada nodo es mayor o igual que sus hijos, cuando se compara utilizando el método de comparación implementado que es global para el montón.

• Clase SplHeap
  • Clase SplMaxHeap
  • Clase SplMinHeap
• Clase SplPriorityQueue

matrices

Los arrays son estructuras que almacenan los datos de forma continua, accesibles a través de índices.No los confundas con matrices PHP:De hecho, las matrices PHP se implementan como tablas hash ordenadas.

• Clase SplFixedArray

Mapa

Un mapa es una estructura de datos que contiene pares clave-valor.Las matrices PHP pueden verse como mapas de números enteros/cadenas a valores.SPL proporciona un mapa desde los objetos hasta los datos.Este mapa también se puede utilizar como conjunto de objetos.

• Clase SplObjectStorage

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

Answer 3

La matriz asociativa se puede utilizar para la mayoría de las estructuras de datos básicas: tabla hash, cola y pila.Pero si quieres algo como un árbol o un montón, no creo que existan de forma predeterminada, pero estoy seguro de que hay bibliotecas gratuitas en cualquier lugar.

Para que una matriz emule un uso de pila array_push() para agregar y array_pop() despegar

Para que una matriz emule un uso de cola array_push() hacer cola y array_shift() quitar la cola

Una matriz asociativa es un hash por defecto.En PHP se les permite tener cadenas como índices, por lo que esto funciona como se esperaba:

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

Finalmente, puedes emular un árbol binario con una matriz con el potencial de desperdiciar espacio.Es útil si sabes que vas a tener un árbol pequeño.Usando una matriz lineal, dice que para cualquier índice (i) coloca su hijo izquierdo en el índice (2i+1) y su hijo derecho en el índice (2i+2).

Todos estos métodos están muy bien tratados en Este artículo sobre cómo hacer que las matrices de JavaScript emulen estructuras de datos de nivel superior.

Answer 4

Aunque esta pregunta tiene 8 años, estoy publicando una respuesta porque PHP 7 introduce una extensión llamada ds proporcionando estructuras de datos especializadas como alternativa a la matriz.

El ds,

• utiliza el Ds\ espacio de nombres.
• tiene 3 interfaces a saber,Collection, Sequence y Hashable
• tiene 8 clases a saber, Vector, Deque,Queue, PriorityQueue, Map, Set, Stack, y Pair

Para más información consulte el Manual y también Esta publicación de blog tiene información increíble, incluidos puntos de referencia.

Answer 5

PHP tiene matrices que en realidad son matrices asociativas y también pueden usarse como conjuntos.Como muchos lenguajes interpretados, PHP ofrece todo esto bajo un mismo capó en lugar de proporcionar diferentes tipos de datos explícitos.

P.ej.

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

/Editar:Además, echa un vistazo en el manual.

Answer 6

PHP formación Funciona como una lista y un diccionario.

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

O para usarlo como una matriz asociativa:

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

Answer 7

Creo que quizás quieras ser un poco más específico, cuando dices estructuras de datos mi mente va en algunas direcciones...

Matrices: ciertamente están bien documentadas y disponibles en.(http://us.php.net/manual/en/book.array.php)

Datos SQL: depende de la base de datos que esté utilizando, pero la mayoría están disponibles.(http://us.php.net/manual/en/book.mysql.php)

POO: Dependiendo de la versión, se pueden diseñar e implementar objetos.(http://us.php.net/manual/en/language.oop.php) Tuve que buscar programación orientada a objetos para encontrar esto en el sitio php.

Espero que ayude, lo siento si no es así.

Answer 8

Por supuesto, PHP tiene estructuras de datos.La matriz en php es increíblemente flexible.Algunos ejemplos:

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

Luego tiene una gran cantidad de funciones de matriz disponibles para mapear/filtrar/recorrer/etc. las estructuras, o convertir, voltear, invertir, etc.

Answer 9

Siempre puedes crear el tuyo propio si no crees que PHP incluya un tipo específico de estructura de datos.Por ejemplo, aquí hay una estructura de datos Set simple respaldada por una matriz.

Conjunto de matrices: 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 también puede tener un conjunto de conjuntos que se denomina "matriz multidimensional" o "matriz".Puede tener matrices bidimensionales, matrices tridimensionales, etc.

Answer 11

Para la necesidad obligatoria de estructuras de datos, busque el SPL(Extensiones PHP).Tienen estructuras de datos como montón, lista enlazada, etc.etc...

PHP no tiene la lista y establece estructuras de datos exactamente.pero se pueden lograr mediante una matriz (con n dimensiones), que proporciona múltiples datos con un solo grupo

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

No son exactamente como una lista o un conjunto.Pero la matriz puede reemplazar eso.Por tanto, no es necesario buscar otras estructuras de datos.

Answer 12

Sí lo hace.

<?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

Los lenguajes C permitirán crear una estructura y luego llenarla como un búfer de cadena (char/byte).Una vez que se completa, el código accede al búfer a través de los miembros de la estructura.Es realmente bueno analizar archivos estructurados (base de datos, imágenes, etc.) de esa manera.No creo que puedas hacer eso con estructuras PHP, o (con suerte) estoy equivocado.

Ok, bueno, PHP tiene descomprimir y empaquetar, funcionalmente igual, pero no tan elegante.