initial

Author: dan-on

.gitignore

@@ -0,0 +1 @@
+vendor

README.md

@@ -0,0 +1,2 @@
+# PHP Interval tree
+Is an implementation of interval binary search tree according to Thomas H. Cormen book "Introduction to Algorithms".

composer.json

@@ -0,0 +1,20 @@
+{
+    "name": "dan-on/php-interval-tree",
+    "description": "Is an implementation of interval binary search tree according to Thomas Cormen book \"Introduction to Algorithms\".",
+    "type": "library",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Daniil Akhmetov",
+            "email": "[email protected]"
+        }
+    ],
+    "autoload": {
+        "psr-4": {
+            "IntervalTree\\": "src/"
+        }
+    },
+    "require": {
+        "php": "^5.3 || ^7.0"
+    }
+}

examples/index.php

@@ -0,0 +1,20 @@
+<?php
+require_once 'vendor/autoload.php';
+
+use 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 
+for ($i=0; $i < count($intervals); $i++) {
+    $tree->insert($intervals[$i],"val" . $i);
+}
+
+// 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) {
+    echo $value . "\n";
+}); 

src/Interval.php

@@ -0,0 +1,78 @@
+<?php
+namespace IntervalTree;
+
+class Interval {
+
+    public $low;
+    public $high;
+
+    public function __construct($low, $high)
+    {
+        $this->low = $low;
+        $this->high = $high;
+    }
+
+
+    public function lessThan(Interval $otherInterval)
+    {
+        return $this->low < $otherInterval->low ||
+            $this->low == $otherInterval->low && $this->high < $otherInterval->high;
+    }
+
+    public function equalTo(Interval $otherInterval) 
+    {
+        return $this->low == $otherInterval->low && $this->high == $otherInterval->high;
+    }
+
+    public function intersect(Interval $otherInterval)
+    {
+        return !$this->notIntersect($otherInterval);
+    }
+
+    public function notIntersect(Interval $otherInterval)
+    {
+        return ($this->high < $otherInterval->low || $otherInterval->high < $this->low);
+    }
+
+    public function merge(Interval $otherInterval)
+    {
+        return new Interval(
+            $this->low === null ? $otherInterval->low : min($this->low, $otherInterval->low),
+            $this->high === null ? $otherInterval->high : max($this->high, $otherInterval->high)
+        );
+    }
+
+    /**
+     * Returns how key should return
+     */
+    public function output() {
+        return [$this->low, $this->high];
+    }
+
+
+
+    /**
+     * Function returns maximum between two comparable values
+     * @param interval1
+     * @param interval2
+     * @returns {Interval}
+     */
+    public static function comparableMax($interval1, $interval2) {
+        return $interval1->merge($interval2);
+    }
+
+    public function getMax()
+    {
+        return clone $this;
+    }
+
+    /**
+     * Predicate returns true if first value less than second value
+     * @param val1
+     * @param val2
+     * @returns {boolean}
+     */
+    public static function comparableLessThan($val1, $val2) {
+        return $val1 < $val2;
+    }
+}