Liste doublement chaînée (php5)

Télécharger le projet
Commenter

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.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (cs_GRenard)