Notes d'étude PHP : structures de données et algorithmes

Notes d'étude PHP : structures de données et algorithmes

Aperçu :
Les structures de données et les algorithmes sont deux concepts très importants en informatique. Ils sont la clé pour résoudre les problèmes et optimiser les performances du code. Dans la programmation PHP, nous devons souvent utiliser diverses structures de données pour stocker et exploiter les données, et nous devons également utiliser des algorithmes pour implémenter diverses fonctions. Cet article présentera certaines structures de données et algorithmes couramment utilisés et fournira des exemples de code PHP correspondants.

1. Structure linéaire

1. Array
   Array est l'une des structures de données les plus couramment utilisées et peut être utilisée pour stocker des ensembles de données ordonnés. Le tableau de PHP est une collection de cartes ordonnées (valeur-clé) et vous pouvez utiliser des indices pour accéder aux éléments du tableau. Voici quelques opérations courantes sur les tableaux :

• Créer un tableau : $arr = array(1, 2, 3);
• Ajouter des éléments : $arr[] = 4;
• Accéder aux éléments : $arr[0] ;
• Supprimer l'élément : unset($arr[0]);
• Longueur du tableau : count($arr);
• Parcours de boucle : foreach ($arr en tant que $value) { ... }

2. Liste chaînée List)
   Une liste chaînée est une structure de données composée d'une série de nœuds, chaque nœud contient des données et un pointeur vers le nœud suivant. Les listes chaînées peuvent réaliser des opérations d'insertion et de suppression efficaces, mais les opérations de recherche sont lentes. Ce qui suit est un exemple simple de liste chaînée :

class Node {
    public $data;
    public $next;

    public function __construct($data = null) {
        $this->data = $data;
        $this->next = null;
    }
}

class LinkedList {
    public $head;

    public function __construct() {
        $this->head = null;
    }

    public function insert($data) {
        $newNode = new Node($data);
        if ($this->head === null) {
            $this->head = $newNode;
        } else {
            $currentNode = $this->head;
            while ($currentNode->next !== null) {
                $currentNode = $currentNode->next;
            }
            $currentNode->next = $newNode;
        }
    }

    public function display() {
        $currentNode = $this->head;
        while ($currentNode !== null) {
            echo $currentNode->data . " ";
            $currentNode = $currentNode->next;
        }
    }
}

$linkedList = new LinkedList();
$linkedList->insert(1);
$linkedList->insert(2);
$linkedList->insert(3);
$linkedList->display();

2. Structure non linéaire

1. Stack (Stack) Stack est une structure de données dernier entré, premier sorti (LIFO) qui peut être implémentée à l'aide d'un tableau. ou liste chaînée. Voici un exemple de pile simple :
   

class Stack {
    private $arr;

    public function __construct() {
        $this->arr = array();
    }

    public function push($data) {
        array_push($this->arr, $data);
    }

    public function pop() {
        if (!$this->isEmpty()) {
            return array_pop($this->arr);
        }
    }

    public function isEmpty() {
        return empty($this->arr);
    }
}

$stack = new Stack();
$stack->push(1);
$stack->push(2);
$stack->push(3);
echo $stack->pop();  // 输出 3

Queue
2. Queue est une structure de données premier entré, premier sorti (FIFO) qui peut être implémentée à l'aide d'un tableau ou d'une liste chaînée. Voici un exemple simple de file d'attente :
   

class Queue {
    private $arr;

    public function __construct() {
        $this->arr = array();
    }

    public function enqueue($data) {
        array_push($this->arr, $data);
    }

    public function dequeue() {
        if (!$this->isEmpty()) {
            return array_shift($this->arr);
        }
    }

    public function isEmpty() {
        return empty($this->arr);
    }
}

$queue = new Queue();
$queue->enqueue(1);
$queue->enqueue(2);
$queue->enqueue(3);
echo $queue->dequeue();  // 输出 1

3. Algorithmes couramment utilisés

Algorithme de tri
1. Tri à bulles
2. Tri par sélection
3. Tri par insertion
4. Tri rapide
5. Tri par fusion
6. Algorithme de recherche
Recherche binaire
8. Algorithme récursif
9. Factorial
10. Séquence de Fibonacci

Ce qui précède sont des exemples de codes pour certaines structures de données et algorithmes courants. En apprenant et en comprenant ces codes, vous pouvez mieux maîtriser les structures de données et les algorithmes de PHP. Bien sûr, il existe de nombreuses autres structures de données et algorithmes qui peuvent être appris et explorés. J'espère que les lecteurs pourront continuer à apprendre et à pratiquer et à améliorer continuellement leurs capacités dans le domaine de la programmation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!