refactoring

Author: dan-on

README.md

@@ -1,5 +1,5 @@
 # PHP Interval tree
-Is an implementation of interval binary search tree according to Thomas H. Cormen book "Introduction to Algorithms".
+Implementation of interval binary search tree.
 
 ## Usage
 
@@ -10,27 +10,30 @@ require_once 'vendor/autoload.php';
 use Danon\IntervalTree\IntervalTree;
 
 $tree = new IntervalTree();
-$intervals = [[6,8],[1,4],[2,3],[5,12],[1,1],[3,5],[5,7]];
-
-// Insert interval as a key and string "val0", "val1" etc. as a value 
+$intervals = [[6, 8], [1, 4], [2, 3], [5, 12], [1, 1], [3, 5], [5, 7]];
+        
+// Insert interval as a key and interval index as a value 
 for ($i=0; $i < count($intervals); $i++) {
-    $tree->insert($intervals[$i], "val" . $i);
+    $tree->insert($intervals[$i], $i);
+}
+
+// Iterate nodes which keys intersect with given interval
+$nodesInRange = $tree->iterateIntersections([2, 3]);
+$intersectedIntervalIndexes = [];
+foreach ($nodesInRange as $node) {
+    $intersectedIntervalIndexes[] = $node->getValue();
 }
+// Expected array: [1, 2, 5]
+
+// Check that interval has at least one intersection
+$tree->hasIntersection([2, 3]);
+// Expected value: true
+
+// Count intervals that has intersections
+$tree->countIntersections([2, 3]);
+// Expected value: 3
 
 // Get array of keys sorted in ascendant order
-$sorted_intervals = $tree->getKeys(); //  expected array [[1,1],[1,4],[5,7],[5,12],[6,8]]
-
-// Search items which keys intersect with given interval, and return array of values
-$valuesInRange = $tree->search([2,3], function($value, $key) {
-    return $value;
-});
-
-print_r($valuesInRange);
-
-// Array
-// (
-//     [0] => val1
-//     [1] => val2
-//     [2] => val5
-// )
-```
+$sortedIntervals = $tree->getKeys(); 
+// Expected array: [[1, 1], [1, 4], [2, 3], [3, 5], [5, 7], [5, 12], [6, 8]]
+```

examples/index.php

@@ -101,7 +101,7 @@ public function iterateIntersections(array $interval): iterable
      * @param array $interval
      * @return boolean
      */
-    public function hasIntersect(array $interval): bool
+    public function hasIntersection(array $interval): bool
     {
         $nodesIterator = $this->iterateIntersections($interval);
         return $nodesIterator->current() !== null;
@@ -126,7 +126,7 @@ public function countIntersections($interval): int
      * @param mixed $value - value representing any object (optional)
      * @return Node - returns reference to inserted node
      */
-    public function insert(array $key, mixed $value = null)
+    public function insert(array $key, $value = null)
     {
         if ($key === null) {
             return;

src/IntervalTree.php

@@ -1,7 +1,8 @@
 <?php
 namespace Danon\IntervalTree;
 
-class Node {
+class Node
+{
 
     public const COLOR_RED = 0;
     public const COLOR_BLACK = 1;
@@ -30,14 +31,15 @@ class Node {
 
     public $max;
 
-    public function __construct($key = null, $value = null, $left = null, $right = null, $parent = null, $color = self::COLOR_BLACK) {
+    public function __construct($key = null, $value = null, $left = null, $right = null, $parent = null, $color = self::COLOR_BLACK)
+    {
 
         $this->left = $left;
         $this->right = $right;
         $this->parent = $parent;
         $this->color = $color;
 
-        $this->item = (object)compact('key', 'value');   // key is supposed to be instance of Interval
+        $this->item = (object) compact('key', 'value'); // key is supposed to be instance of Interval
 
         /* If not, this should by an array of two numbers */
         if ($key && is_array($key) && count($key) === 2) {
@@ -47,64 +49,73 @@ public function __construct($key = null, $value = null, $left = null, $right = n
         $this->max = $this->item->key ? clone $this->item->key : null;
     }
 
-    public function getValue() {
+    public function getValue()
+    {
         return $this->item->value;
     }
 
-
-    public function getKey() {
+    public function getKey()
+    {
         return $this->item->key;
     }
 
-    public function isNil() {
+    public function isNil()
+    {
         return ($this->item->key === null && $this->item->value === null &&
             $this->left === null && $this->right === null && $this->color === Node::COLOR_BLACK);
     }
 
-    public function lessThan($otherNode) {
+    public function lessThan($otherNode)
+    {
         return $this->item->key->lessThan($otherNode->item->key);
     }
 
-    public function equalTo($otherNode) {
+    public function equalTo($otherNode)
+    {
         $valueEqual = true;
         if ($this->item->value && $otherNode->item->value) {
             $valueEqual = $this->item->value ? $this->item->value->equalTo($otherNode->item->value) :
-                $this->item->value == $otherNode->item->value;
+            $this->item->value == $otherNode->item->value;
         }
         return $this->item->key->equalTo($otherNode->item->key) && $valueEqual;
     }
 
-    public function intersect($otherNode) {
+    public function intersect($otherNode)
+    {
         return $this->item->key->intersect($otherNode->item->key);
     }
 
-    public function copyData($otherNode) {
+    public function copyData($otherNode)
+    {
         $this->item->key = clone $otherNode->item->key;
         $this->item->value = $otherNode->item->value;
     }
 
-    public function updateMax() {
+    public function updateMax()
+    {
         // use key (Interval) max property instead of key.high
         $this->max = $this->item->key ? $this->item->key->getMax() : null;
         if ($this->right && $this->right->max) {
-            $this->max = Interval::comparableMax($this->max, $this->right->max);  // static method
+            $this->max = Interval::comparableMax($this->max, $this->right->max); // static method
         }
         if ($this->left && $this->left->max) {
             $this->max = Interval::comparableMax($this->max, $this->left->max);
         }
     }
 
     // Other_node does not intersect any node of left subtree, if this.left.max < other_node.item.key.low
-    public function notIntersectLeftSubtree($searchNode) {
+    public function notIntersectLeftSubtree($searchNode)
+    {
         //const comparable_less_than = this.item.key.constructor.comparable_less_than;  // static method
         $high = $this->left->max->high !== null ? $this->left->max->high : $this->left->max;
         return Interval::comparableLessThan($high, $searchNode->item->key->low);
     }
 
     // Other_node does not intersect right subtree if other_node.item.key.high < this.right.key.low
-    public function notIntersectRightSubtree($searchNode) {
+    public function notIntersectRightSubtree($searchNode)
+    {
         //const comparable_less_than = this.item.key.constructor.comparable_less_than;  // static method
         $low = $this->right->max->low !== null ? $this->right->max->low : $this->right->item->key->low;
         return Interval::comparableLessThan($searchNode->item->key->high, $low);
     }
-}
+}