Merge branch 'TheAlgorithms:master' into khouloudHaddad

Author: khouloudhaddad

DIRECTORY.md

@@ -27,12 +27,21 @@
     * [Bstnode](./DataStructures/BinarySearchTree/BSTNode.php)
     * [Bstree](./DataStructures/BinarySearchTree/BSTree.php)
     * [Duplicatekeyexception](./DataStructures/BinarySearchTree/DuplicateKeyException.php)
+  * Comparebinarytree
+    * [Binarytreenode](./DataStructures/CompareBinaryTree/BinaryTreeNode.php)
+    * [Comparebinarytree](./DataStructures/CompareBinaryTree/CompareBinaryTree.php)
   * Disjointsets
     * [Disjointset](./DataStructures/DisjointSets/DisjointSet.php)
     * [Disjointsetnode](./DataStructures/DisjointSets/DisjointSetNode.php)
   * [Doublylinkedlist](./DataStructures/DoublyLinkedList.php)
+  * Invertbinarytree
+    * [Binarytree](./DataStructures/InvertBinaryTree/BinaryTree.php)
+    * [Invertbinarytree](./DataStructures/InvertBinaryTree/InvertBinaryTree.php)
   * [Node](./DataStructures/Node.php)
   * [Queue](./DataStructures/Queue.php)
+  * Reverselinkedlist
+    * [Linkedlistitem](./DataStructures/ReverseLinkedList/LinkedListItem.php)
+    * [Reverselinkedlist](./DataStructures/ReverseLinkedList/ReverseLinkedList.php)
   * Segmenttree
     * [Segmenttree](./DataStructures/SegmentTree/SegmentTree.php)
     * [Segmenttreenode](./DataStructures/SegmentTree/SegmentTreeNode.php)
@@ -50,6 +59,8 @@
   * [Bellmanford](./Graphs/BellmanFord.php)
   * [Breadthfirstsearch](./Graphs/BreadthFirstSearch.php)
   * [Depthfirstsearch](./Graphs/DepthFirstSearch.php)
+  * [Dijkstras](./Graphs/Dijkstras.php)
+  * [Graphedge](./Graphs/GraphEdge.php)
 
 ## Maths
   * [Absolutemax](./Maths/AbsoluteMax.php)
@@ -139,9 +150,12 @@
   * Datastructures
     * [Avltreetest](./tests/DataStructures/AVLTreeTest.php)
     * [Bstreetest](./tests/DataStructures/BSTreeTest.php)
+    * [Comparebinarytreetest](./tests/DataStructures/CompareBinaryTreeTest.php)
     * [Disjointsettest](./tests/DataStructures/DisjointSetTest.php)
     * [Doublylinkedlisttest](./tests/DataStructures/DoublyLinkedListTest.php)
+    * [Invertbinarytreetest](./tests/DataStructures/InvertBinaryTreeTest.php)
     * [Queuetest](./tests/DataStructures/QueueTest.php)
+    * [Reverselinkedlisttest](./tests/DataStructures/ReverseLinkedListTest.php)
     * [Segmenttreetest](./tests/DataStructures/SegmentTreeTest.php)
     * [Singlylinkedlisttest](./tests/DataStructures/SinglyLinkedListTest.php)
     * [Splaytreetest](./tests/DataStructures/SplayTreeTest.php)
@@ -151,6 +165,7 @@
     * [Bellmanfordtest](./tests/Graphs/BellmanFordTest.php)
     * [Breadthfirstsearchtest](./tests/Graphs/BreadthFirstSearchTest.php)
     * [Depthfirstsearchtest](./tests/Graphs/DepthFirstSearchTest.php)
+    * [Dijkstrastest](./tests/Graphs/DijkstrasTest.php)
   * Maths
     * [Eratosthenessievetest](./tests/Maths/EratosthenesSieveTest.php)
     * [Mathstest](./tests/Maths/MathsTest.php)

DataStructures/CompareBinaryTree/BinaryTreeNode.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace DataStructures\CompareBinaryTree;
+
+class BinaryTreeNode
+{
+    public function __construct($value, ?BinaryTreeNode $left = null, BinaryTreeNode $right = null)
+    {
+        $this->value = $value;
+        $this->left = $left;
+        $this->right = $right;
+    }
+
+    public $value;
+    public ?BinaryTreeNode $left;
+    public ?BinaryTreeNode $right;
+}

DataStructures/CompareBinaryTree/CompareBinaryTree.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace DataStructures\CompareBinaryTree;
+
+/**
+ * Recurrent comparison of binary trees based on comparison of left and right branches
+ * (https://en.wikipedia.org/wiki/Binary_tree).
+ *
+ * @author Michał Żarnecki https://github.com/rzarno
+ */
+class CompareBinaryTree
+{
+    /**
+     * compare two binary trees
+     * @param BinaryTreeNode|null $a
+     * @param BinaryTreeNode|null $b
+     * @return bool
+     */
+    public function areTreesEqual(?BinaryTreeNode $a, ?BinaryTreeNode $b): bool
+    {
+        if (! $a  &&  $b || $a && ! $b) {
+            return false;
+        }
+
+        if (! $a && ! $b) {
+            return true;
+        }
+
+        if ($a->value !== $b->value) {
+            return false;
+        }
+        return  $this->areTreesEqual($a->left, $b->left)
+            &&  $this->areTreesEqual($a->right, $b->right);
+    }
+}

DataStructures/InvertBinaryTree/BinaryTree.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace DataStructures\InvertBinaryTree;
+
+class BinaryTree
+{
+    private ?BinaryTree $left = null;
+    private ?BinaryTree $right = null;
+    private $value;
+
+    public function setLeft(?BinaryTree $left)
+    {
+        $this->left = $left;
+        return $this;
+    }
+
+    public function getLeft(): ?BinaryTree
+    {
+        return $this->left;
+    }
+
+    public function setRight(?BinaryTree $right)
+    {
+        $this->right = $right;
+        return $this;
+    }
+
+    public function getRight(): ?BinaryTree
+    {
+        return $this->right;
+    }
+
+    public function setValue($value)
+    {
+        $this->value = $value;
+        return $this;
+    }
+
+    public function getValue()
+    {
+        return $this->value;
+    }
+}

DataStructures/InvertBinaryTree/InvertBinaryTree.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace DataStructures\InvertBinaryTree;
+
+/**
+ * Recurrent algorithm to invert binary tree (mirror)
+ * (https://medium.com/@kvrware/inverting-binary-tree-b0ff3a5cb0df).
+ *
+ * @author Michał Żarnecki https://github.com/rzarno
+ */
+class InvertBinaryTree
+{
+    public function invert(?BinaryTree $b): void
+    {
+        if (! $b) {
+            return;
+        }
+        $tmp = $b->getLeft();
+        $b->setLeft($b->getRight());
+        $b->setRight($tmp);
+        $this->invert($b->getLeft());
+        $this->invert($b->getRight());
+    }
+}

DataStructures/ReverseLinkedList/LinkedListItem.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace DataStructures\ReverseLinkedList;
+
+class LinkedListItem
+{
+    private ?LinkedListItem $next = null;
+    private ?LinkedListItem $prev = null;
+    private $value;
+
+    public function setNext(?LinkedListItem $next)
+    {
+        $this->next = $next;
+        return $this;
+    }
+
+    public function getNext(): ?LinkedListItem
+    {
+        return $this->next;
+    }
+
+    public function setPrev(?LinkedListItem $prev)
+    {
+        $this->prev = $prev;
+        return $this;
+    }
+
+    public function getPrev(): ?LinkedListItem
+    {
+        return $this->prev;
+    }
+
+    public function setValue($value)
+    {
+        $this->value = $value;
+        return $this;
+    }
+
+    public function getValue()
+    {
+        return $this->value;
+    }
+}

DataStructures/ReverseLinkedList/ReverseLinkedList.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace DataStructures\ReverseLinkedList;
+
+/**
+ * Reverse linked list
+ * (https://en.wikipedia.org/wiki/Linked_list).
+ *
+ * @author Michał Żarnecki https://github.com/rzarno
+ */
+class ReverseLinkedList
+{
+    public function reverse(LinkedListItem $item): LinkedListItem
+    {
+        $next = $item->getNext();
+        $item->setNext(null);
+        while (true) {
+            $item->setPrev($next);
+            if (! $next) {
+                return $item;
+            }
+            $nextNext = $next->getNext();
+            $next->setNext($item);
+            $item = $next;
+            $next = $nextNext;
+        }
+    }
+}

Graphs/BellmanFord.php

@@ -1,23 +1,17 @@
 <?php
 
-class Edge
-{
-    public $start;
-    public $end;
-    public int $weight;
-}
-
 /**
  * The Bellman–Ford algorithm is an algorithm that computes shortest paths from a single source vertex to all of the
  * other vertices in a weighted digraph.
  * (https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm).
  *
  * @author Michał Żarnecki https://github.com/rzarno
- * @param array $verticies An array of verticies names
- * @param Edge[] $edges An array of edges
- * @return string $start The starting vertex
+ * @param array $verticesNames An array of vertices names
+ * @param GraphEdge[] $edges An array of edges
+ * @param string $start The starting vertex
+ * @return array An array of shortest paths from $start to all other vertices
  */
-function bellmanFord(array $verticesNames, array $edges, string $start, bool $verbose = false)
+function bellmanFord(array $verticesNames, array $edges, string $start, bool $verbose = false): array
 {
     $vertices = array_combine($verticesNames, array_fill(0, count($verticesNames), PHP_INT_MAX));
 
@@ -30,7 +24,7 @@ function bellmanFord(array $verticesNames, array $edges, string $start, bool $ve
         $change = false;
         foreach ($vertices as $vertice => $minWeight) {
             if ($verbose) {
-                echo "checking vertice $vertice\n";
+                echo "checking vertex $vertice\n";
             }
             if ($start === $vertice) {
                 $vertices[$vertice] = 0;
@@ -39,7 +33,8 @@ function bellmanFord(array $verticesNames, array $edges, string $start, bool $ve
             foreach ($edges[$vertice] as $edge) {
                 if ($vertices[$edge->end] > $vertices[$vertice] + $edge->weight) {
                     if ($verbose) {
-                        echo "replace $vertice " . $vertices[$edge->end] . " with " . $vertices[$vertice] + $edge->weight . "\n ";
+                        echo "replace $vertice " . $vertices[$edge->end] . " with "
+                            . ($vertices[$vertice] + $edge->weight) . "\n ";
                     }
                     $vertices[$edge->end] = $vertices[$vertice] + $edge->weight;
                     $change = true;

Graphs/Dijkstras.php

@@ -0,0 +1,43 @@
+<?php
+
+/**
+ * The Dijkstra's algorithm is an algorithm for finding the shortest paths between nodes in a weighted graph.
+ * (https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm).
+ *
+ * @author Michał Żarnecki https://github.com/rzarno
+ * @param array $verticesNames An array of vertices names
+ * @param GraphEdge[] $edges An array of edges
+ * @param string $start The starting vertex
+ * @return array An array of shortest paths from $start to all other vertices
+ */
+function dijkstras(array $verticesNames, array $edges, string $start): array
+{
+    $vertices = array_combine($verticesNames, array_fill(0, count($verticesNames), PHP_INT_MAX));
+    $visitedNodes = [];
+
+    $nextVertex = $start;
+    $vertices[$start] = 0;
+    while (count($visitedNodes) < count($verticesNames)) { //continue until all nodes are visited
+        foreach ($edges as $edge) {
+            if ($edge->start == $nextVertex) { //consider only nodes connected to current one
+                $vertices[$edge->end] = min($vertices[$edge->end], $vertices[$nextVertex] + $edge->weight);
+            }
+        }
+
+        // find vertex with current lowest value to be starting point in next iteration
+        $minVertexName = null;
+        $minVertexWeight = PHP_INT_MAX;
+        foreach ($vertices as $name => $weight) {
+            if (in_array($name, $visitedNodes) || $name == $nextVertex) {
+                continue;
+            }
+            if ($weight <= $minVertexWeight) {
+                $minVertexName = $name;
+                $minVertexWeight = $weight;
+            }
+        }
+        $visitedNodes[] = $nextVertex;
+        $nextVertex = $minVertexName;
+    }
+    return $vertices;
+}

Graphs/GraphEdge.php

@@ -0,0 +1,8 @@
+<?php
+
+class GraphEdge
+{
+    public string $start;
+    public string $end;
+    public int $weight;
+}