improvements in sorting algorithms, new class InsertionSort, minor fixes and improvements

Author: doganoo

src/Algorithm/Sorting/BubbleSort.php

@@ -41,7 +41,11 @@ class BubbleSort implements ISortable {
      * @return array
      */
     public function sort(array $array): array {
+        $array = \array_values($array);
         $length = \count($array);
+
+        if (0 === $length || 1 === $length) return $array;
+
         for ($i = 0; $i < $length; $i++) {
             for ($j = 0; $j < $length - $i - 1; $j++) {
                 if (Comparator::greaterThan($array[$j], $array[$j + 1])) {

src/Algorithm/Sorting/InsertionSort.php

@@ -0,0 +1,60 @@
+<?php
+/**
+ * MIT License
+ *
+ * Copyright (c) 2018 Dogan Ucar
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+namespace doganoo\PHPAlgorithms\Algorithm\Sorting;
+
+
+use doganoo\PHPAlgorithms\Common\Interfaces\ISortable;
+use doganoo\PHPAlgorithms\Common\Util\Comparator;
+
+/**
+ * Class InsertionSort
+ *
+ * @package doganoo\PHPAlgorithms\Algorithm\Sorting
+ */
+class InsertionSort implements ISortable {
+
+    /**
+     * @param array $array
+     * @return array
+     */
+    public function sort(array $array): array {
+        $array = \array_values($array);
+        $size = \count($array);
+
+        if (0 === $size || 1 === $size) return $array;
+
+        for ($i = 1; $i < $size; $i++) {
+            $j = $i;
+            while (($j > 0) && (Comparator::lessThan($array[$j], $array[$j - 1]))) {
+                $tmp = $array[$j - 1];
+                $array[$j - 1] = $array[$j];
+                $array[$j] = $tmp;
+                $j--;
+            }
+        }
+        return $array;
+    }
+}

src/Algorithm/Sorting/MergeSort.php

@@ -42,10 +42,11 @@ class MergeSort implements ISortable {
      * @return array
      */
     public function sort(array $array): array {
+        $array = \array_values($array);
         $arraySize = count($array);
-        if ($arraySize == 1) {
-            return $array;
-        }
+
+        if (0 === $arraySize || $arraySize == 1) return $array;
+
         $middle = floor($arraySize / 2);
         $left = array_slice($array, 0, $middle);
         $right = array_slice($array, $middle);
@@ -60,13 +61,14 @@ public function sort(array $array): array {
      * @return array
      */
     private function merge(?array $left, ?array $right): array {
-        if ($left == null) {
-            return [];
-        }
-        if ($right == null) {
-            return [];
-        }
+
+        if (null === $left) return [];
+        if (null === $right) return [];
+
         $result = [];
+        $left = \array_values($left);
+        $right = \array_values($right);
+
         while (count($left) !== 0 && count($right) !== 0) {
             if (Comparator::greaterThan($left[0], $right[0])) {
                 $result[] = $right[0];

src/Algorithm/Sorting/QuickSort.php

@@ -40,32 +40,29 @@ class QuickSort implements ISortable {
      * @return array
      */
     public function sort(array $array): array {
+        $array = \array_values($array);
         $arraySize = count($array);
-        if ($arraySize == 1) {
-            return $array;
-        }
 
-        $pivot = $array[1];
+        if (0 === $arraySize || $arraySize == 1) return $array;
+
+        $pivot = $array[1]; //TODO how to choose the best pivot?!
         $left = [];
         $right = [];
 
         while (count($array) !== 0) {
-            $key = key($array);
-            $value = current($array);
-            unset($array[$key]);
+            $value = $array[0];
 
             if (Comparator::lessThan($value, $pivot)) {
                 $left[] = $value;
             } else {
                 $right[] = $value;
             }
+            $array = \array_slice($array, 1);
         }
         return array_merge(
             $this->sort($left)
             , [$pivot]
             , $this->sort($right)
         );
     }
-
-
 }

src/Algorithm/Sorting/SelectionSort.php

@@ -47,6 +47,9 @@ class SelectionSort implements ISortable {
     public function sort(array $array): array {
         $array = \array_values($array);
         $length = \count($array);
+
+        if (0 === $length || 1 === $length) return $array;
+
         for ($i = 0; $i < $length; $i++) {
             $min = $i;
             for ($j = $i; $j < $length; $j++) {

src/Datastructure/Maps/HashMap.php

@@ -380,4 +380,18 @@ public function keySet(): array {
         }
         return $keySet;
     }
+
+    /**
+     * @return array
+     */
+    public function countPerBucket() {
+        $i = 0;
+        $array = [];
+        /** @var SinglyLinkedList $list */
+        foreach ($this->bucket as $list) {
+            $array[$i] = $list->size();
+            $i++;
+        }
+        return $array;
+    }
 }

tests/Lists/ArrayLists/ArrayListTest.php

@@ -171,4 +171,52 @@ public function testIterator() {
         $this->assertTrue($i === $arrayList->length());
     }
 
+    public function testSerialize() {
+        $arrayList = new ArrayList();
+        $x = new class {
+            public $id;
+        };
+        $x->id = 1;
+        $arrayList->add($x);
+        $x->id = 2;
+        $arrayList->add($x);
+        $x->id = 3;
+        $arrayList->add($x);
+        $x->id = 4;
+        $arrayList->add($x);
+        $x->id = 5;
+        $arrayList->add($x);
+        $x->id = 6;
+        $arrayList->add($x);
+        $x->id = 7;
+        $arrayList->add($x);
+        $x->id = 8;
+        $arrayList->add($x);
+        $x->id = 9;
+        $arrayList->add($x);
+        $x->id = 10;
+        $arrayList->add($x);
+        $x->id = 11;
+        $arrayList->add($x);
+        $x->id = 12;
+        $arrayList->add($x);
+        $x->id = 13;
+        $arrayList->add($x);
+        $x->id = 14;
+        $arrayList->add($x);
+        $x->id = 15;
+        $arrayList->add($x);
+        $x->id = 16;
+        $arrayList->add($x);
+        $x->id = 17;
+        $arrayList->add($x);
+
+        $json = json_encode($arrayList);
+        $this->assertTrue(false !== is_string($json));
+
+        $list = json_decode($json);
+
+        $this->assertTrue(null !== $list && $list instanceof stdClass);
+    }
+
 }

tests/Sorting/SortTest.php

@@ -25,6 +25,7 @@
 
 
 use doganoo\PHPAlgorithms\Algorithm\Sorting\BubbleSort;
+use doganoo\PHPAlgorithms\Algorithm\Sorting\InsertionSort;
 use doganoo\PHPAlgorithms\Algorithm\Sorting\MergeSort;
 use doganoo\PHPAlgorithms\Algorithm\Sorting\SelectionSort;
 
@@ -50,4 +51,10 @@ public function testMergeSort() {
         $result = $bubbleSort->sort($arr);
         $this->assertTrue($result === [1, 9, 12, 13, 40, 55]);
     }
+    public function testInsertionSort() {
+        $bubbleSort = new InsertionSort();
+        $arr = [12, 40, 9, 55, 1, 13];
+        $result = $bubbleSort->sort($arr);
+        $this->assertTrue($result === [1, 9, 12, 13, 40, 55]);
+    }
 }