Liste doublement chaînée (php5)

Soyez le premier à donner votre avis sur cette source.

Vue 11 622 fois - Téléchargée 291 fois

Description

Voici une liste doublement chaînée basée sur un code C++ que j'ai écrit.
Elle permet d'inscrire des variables dans une liste créée dynamiquement en mémoire.
Normalement, toutes les fonctions des classes possèdent des templates (afin de contenir n'importe quel type que cela soit (int, double, string...)), mais en PHP, il n'est pas nécessaire de faire cela car tout est déjà fait automatiquement.
Notez qu'il y a beaucoup de passage par référence ! car on ne doit pas faire de copie mais passer des pointeurs. Cette notion est plus visible en C++ qu'en PHP.
Vous pouvez aussi remarquer le === qui compare 2 classes en PHP.

Normalement, le code est surchargé d'opérateur du style
+= -> addNode()
++ -> nextCurrent()
-- -> prevCurrent()
() -> getCurrent()

Mais PHP ne permet pas encore ces fonctionnalités.

Compatible PHP5 seulement.

Source / Exemple :


<?php
// node.php
class TNode {
	public $nextPtr;		// Node *
	public $prevPtr;		// Node *
	public $currentPtr;		// Value

	function __construct($value) {
		$this->prevPtr = NULL;
		$this->nextPtr = NULL;
		$this->currentPtr = $value;
	}

	function __destruct() {
		$this->currentPtr = NULL;
	}
};
?>

<?php
// list.php
include_once "node.php";

class TList {
	private $currentPtr;	// TNode

	function __construct() {
		$this->currentPtr = NULL;
	}

	function __destruct() {
		$this->DeleteAll();
	}

	/**

  • @return bool
  • @desc Deletes all Nodes
  • /
public function DeleteAll() { if( !$this->isEmpty() ) { // We remove Circular loop $this->currentPtr->prevPtr->nextPtr = NULL; // We crate a temp $tempPtr = NULL; while( $this->currentPtr !== NULL ) { // We save the actual position $tempPtr = $this->currentPtr; // We move our current $this->currentPtr = $this->currentPtr->nextPtr; // We delete the space before current $tempPtr = NULL; } // Reseting Variable $this->currentPtr = NULL; return true; } else { return false; } } /**
  • @return bool
  • @desc Removes current Node
  • /
public function RemoveNode() { if( !$this->isEmpty() ) { // If the list contains only 1 node if( $this->currentPtr->nextPtr === $this->currentPtr) { // === comparing object classes $this->currentPtr = NULL; } else { $tempPtr = NULL; $this->currentPtr->prevPtr->nextPtr = $this->currentPtr->nextPtr; $this->currentPtr->nextPtr->prevPtr = $this->currentPtr->prevPtr; $tempPtr = $this->currentPtr; $this->currentPtr = $this->currentPtr->nextPtr; $tempPtr = NULL; } return true; } return false; } /**
  • @return bool
  • @desc Returns true if the list is empty
  • /
private function isEmpty() { return ($this->currentPtr === NULL); } /**
  • @return TNode *
  • @param mixed $value
  • @desc Return Pointer to newly allocated node
  • /
public function getNewNode($value) { $ptr = new TNode($value); return $ptr; } /**
  • @return void
  • @param mixed $value
  • @desc Add Node with value
  • /
public function addNode($value) { $newPtr = $this->getNewNode($value); // We have to case : Empty list, Non Empty List if( $this->isEmpty() ) { $newPtr->prevPtr = $newPtr; $newPtr->nextPtr = $newPtr; } else { $newPtr->nextPtr = $this->currentPtr->nextPtr; $newPtr->prevPtr = $this->currentPtr; $this->currentPtr->nextPtr = $newPtr; $newPtr->nextPtr->prevPtr = $newPtr; } $this->currentPtr = $newPtr; } /**
  • @return bool
  • @desc Move current to the next position
  • /
public function nextCurrent() { if( !$this->isEmpty() ) { $this->currentPtr = $this->currentPtr->nextPtr; return true; } else { return false; } } /**
  • @return bool
  • @desc Move current to the prev position
  • /
public function prevCurrent(){ if( !$this->isEmpty() ) { $this->currentPtr = $this->currentPtr->prevPtr; return true; } else { return false; } } /**
  • @return mixed
  • @desc Return the value hosted by Node
  • /
public function &getCurrent() { if( !$this->isEmpty() ) { return $this->currentPtr->currentPtr; } else { return NULL; } } }; ?> <?php // example.php // Normally, all functions are templated. But in PHP, // it is already templated. include_once "list.php"; $a = new TList; $a->addNode(20); // Add 20 $a->addNode(30); // Add 30 $a->addNode(40); // Add 40 $a->addNode(50); // Add 50 $a->addNode(100); // Add 100 $a->prevCurrent(); // Select Previous (50) $a->RemoveNode(); // Remove Current (50). 100 is Selected $a->nextCurrent(); // Select Next (20) $a->nextCurrent(); // Select Next (30) $a->addNode(35); // Add 35 (next to 30) $a->nextCurrent(); // Select 40 echo $a->getCurrent(); // Return 40 ?>

Conclusion :


Pourquoi une class Node ? Car cela permet de rendre le code plus modulaire, ainsi s'il y a une modification à faire sur les valeurs à enregistrer, nous modifieront la class Node. Si nous devons modifier une fonction de la liste, il nous sera inutile de toucher à la class Node.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

kryz0gen
Messages postés
1
Date d'inscription
vendredi 24 octobre 2008
Statut
Membre
Dernière intervention
9 novembre 2011

Code très lisible et élégant.Beau boulot.
cs_GRenard
Messages postés
1662
Date d'inscription
lundi 16 septembre 2002
Statut
Membre
Dernière intervention
30 juillet 2008
1
Les itérateurs de PHP? ArrayObject et tout le kit ?
Je n'avais jamais vu moi même... c'est surement assez nouveau. Peut être qu'il y a la même chose, je vois des fonctions similaires.
FhX
Messages postés
2350
Date d'inscription
mercredi 13 octobre 2004
Statut
Membre
Dernière intervention
18 avril 2015
3
Les Itérateurs ne peuvent pas te permettre de faire la même chose ?
malalam
Messages postés
10840
Date d'inscription
lundi 24 février 2003
Statut
Modérateur
Dernière intervention
2 mars 2010
20
Hello,

je n'avais pas vu ce code.
Je ne l'ai pas testé (mais je le ferai, manque de temps là), mais c'est très joli. Et cela peut-être très utile. Bref, c'est une bonne idée, les Tlist manquent à php :-)
tryskehl
Messages postés
34
Date d'inscription
vendredi 14 mai 2004
Statut
Membre
Dernière intervention
19 août 2004

Ok, merci pour ton aide.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.