├── README.markdown
├── data_structure
    ├── queue
    │   ├── queue_using_spl.php
    │   ├── queue_using_array.php
    │   ├── README.markdown
    │   └── queue_using_class.php
    ├── stack
    │   ├── stack_using_spl.php
    │   ├── stack_using_array.php
    │   ├── README.markdown
    │   └── stack_using_class.php
    ├── linked_list
    │   ├── README.markdown
    │   ├── linked_list_using_spl.php
    │   └── linked_list_using_class.php
    └── tree
    │   └── binary_search_tree.php
└── algorithm
    └── sort
        ├── bubble_sort.php
        ├── quick_sort.php
        ├── bucket_sort.php
        ├── radix_sort.php
        ├── insertion_sort.php
        ├── counting_sort.php
        ├── merge_sort.php
        └── heap_sort.php


/README.markdown:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/data_structure/queue/queue_using_spl.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Queue implementation using SplQueue class.
 4 |  *
 5 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 6 |  *
 7 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
 8 |  * license.
 9 |  */
10 | 
11 | $queue = new SplQueue();
12 | $queue->enqueue("Element");
13 | $queue->enqueue(23);
14 | $queue->enqueue(array(3, 4, 6));
15 | 
16 | while (!$queue->isEmpty()) {
17 |   var_dump($queue->dequeue());
18 | }
19 | 
20 | if ($queue->isEmpty()) {
21 |   // Element can be any type
22 |   $queue->enqueue(new SplStack());
23 | }
24 | 
25 | // Throws RuntimeException if the queue is empty
26 | var_dump($queue->top());
27 | 


--------------------------------------------------------------------------------
/data_structure/stack/stack_using_spl.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Stack implementation using SplStack class.
 4 |  *
 5 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 6 |  *
 7 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
 8 |  * license.
 9 |  */
10 | 
11 | $stack = new SplStack();
12 | $stack->push("Element");
13 | $stack->push(23);
14 | $stack->push(array(3, 4, 6));
15 | 
16 | while (!$stack->isEmpty()) {
17 |   var_dump($stack->top());
18 |   $stack->pop();
19 | }
20 | 
21 | if ($stack->isEmpty()) {
22 |   // Element can be any type
23 |   $stack->push(new SplStack());
24 | }
25 | 
26 | // Throws RuntimeException if the stack is empty
27 | var_dump($stack->top());
28 | 


--------------------------------------------------------------------------------
/data_structure/stack/stack_using_array.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Stack implementation using array.
 4 |  *
 5 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 6 |  *
 7 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
 8 |  * license.
 9 |  */
10 | 
11 | $stack = array();
12 | 
13 | // The top element is the last element in array.
14 | if (empty($stack)) {
15 |   array_push($stack, 0);
16 |   array_push($stack, 3);
17 |   array_push($stack, 7);
18 |   array_push($stack, 13);
19 | }
20 | 
21 | var_dump($stack);
22 | 
23 | if (!empty($stack)) {
24 |   array_pop($stack);
25 | }
26 | var_dump($stack);
27 | 
28 | if (!empty($stack)) {
29 |   $top = array_pop($stack);
30 |   echo "The top element being dequeued is $top\n";
31 | }
32 | 


--------------------------------------------------------------------------------
/data_structure/linked_list/README.markdown:
--------------------------------------------------------------------------------
 1 | # Implementing linked list in PHP #
 2 | Linked list can be implemented in several ways using PHP. Using array is
 3 | excluded from the examples. The following examples only provide class implemen-
 4 | tation and built-in SplDoublyLinkedList. Please note, these examples are
 5 | **doubly-linked-list** implementation.
 6 | 
 7 | 1. Object Node wrapped as a property in LinkedList class.
 8 |    See `linked_list_using_class.php`.
 9 | 2. Using [`SplDoublyLinkedList` class] [1].
10 |    Available for PHP 5+.
11 | 
12 | All examples are executed directly in CLI.
13 | 
14 |     ~$ php linked_list_using_class.php
15 |     ~$ php linked_list_using_spl.php
16 | 
17 |   [1]: http://www.php.net/manual/en/class.spldoublylinkedlist.php "SplDoublyLinkedList class"
18 | 


--------------------------------------------------------------------------------
/data_structure/stack/README.markdown:
--------------------------------------------------------------------------------
 1 | # Implementing stack in PHP #
 2 | Stack can be implemented in several ways using PHP.
 3 | 
 4 | 1. Using array.
 5 |    Use [`array_push`] [1] and [`array_pop`] [2]
 6 |    See `stack_using_array.php`.
 7 | 2. Array wrapped as a property in a class.
 8 |    See `stack_using_class.php`.
 9 | 3. Using [`SplStack` class] [3].
10 |    Available for PHP 5+.
11 | 
12 | All examples are executed directly in CLI.
13 | 
14 |     ~$ php stack_using_array.php
15 |     ~$ php stack_using_class.php
16 |     ~$ php stack_using_spl.php
17 | 
18 |   [1]: http://www.php.net/manual/en/function.array-push.php "array_push"
19 |   [2]: http://www.php.net/manual/en/function.array-pop.php  "array_pop"
20 |   [3]: http://www.php.net/manual/en/class.splstack.php      "SplStack class"
21 | 


--------------------------------------------------------------------------------
/data_structure/queue/queue_using_array.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Queue implementation using array.
 4 |  *
 5 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 6 |  *
 7 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
 8 |  * license.
 9 |  */
10 | 
11 | $queue = array();
12 | 
13 | // The front element in the queue is the first index
14 | if (empty($queue)) {
15 |   array_push($queue, 0);
16 |   array_push($queue, 3);
17 |   array_push($queue, 7);
18 |   array_push($queue, 13);
19 | }
20 | 
21 | if (!empty($queue)) {
22 |   echo "The front element in the queue is : " . $queue[0] . "\n";
23 |   echo "The front element being dequeued : " . array_shift($queue) . "\n\n";
24 | 
25 |   echo "The front element in the queue is now : " . $queue[0] . "\n";  
26 |   echo "The front element being dequeued : " . array_shift($queue) . "\n\n";
27 | 
28 |   echo "The front element in the queue is now : " . $queue[0] . "\n";
29 | }
30 | 


--------------------------------------------------------------------------------
/data_structure/queue/README.markdown:
--------------------------------------------------------------------------------
 1 | # Implementing queue in PHP #
 2 | Queue can be implemented in several ways using PHP.
 3 | 
 4 | 1. Using array.
 5 |    With the assumption of using numerical indices, we can get the front element
 6 |    in the queue by accessing $queue[0], use [`array_push`] [1] to enqueue
 7 |    element into queue, and [`array_shift`] [2] to dequeue element from the
 8 |    queue.
 9 |    See `queue_using_array.php`.
10 | 2. Array wrapped as a property in a class.
11 |    See `queue_using_class.php`.
12 | 3. Using [`SplQueue` class] [3].
13 |    Available for PHP 5+.
14 | 
15 | All examples are executed directly in CLI.
16 | 
17 |     ~$ php queue_using_array.php
18 |     ~$ php queue_using_class.php
19 |     ~$ php queue_using_spl.php
20 | 
21 |   [1]: http://www.php.net/manual/en/function.array-push.php  "array_push"
22 |   [2]: http://www.php.net/manual/en/function.array-shift.php "array_shift"
23 |   [3]: http://www.php.net/manual/en/class.splqueue.php       "SplQueue class"
24 | 


--------------------------------------------------------------------------------
/algorithm/sort/bubble_sort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Implementation of bubble sort algorithm in PHP. This code is
 4 |  * direct pseudo-code implementation from Cormen et al book, Introduction
 5 |  * to Algorithms.
 6 |  *
 7 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 8 |  *
 9 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
10 |  * license.
11 |  */
12 | 
13 | function bubble_sort(&$elements, $fn = 'comparison_function') {
14 |   for ($i = 0; $i < sizeof($elements) - 1; $i++) {
15 |     for ($j = sizeof($elements) - 1; $j >= ($i + 1); $j--) {
16 |       if ( $fn($elements[$j], $elements[$j-1]) ) {
17 |         // swap the element
18 |         $elements[$j]   ^= $elements[$j-1];
19 |         $elements[$j-1] ^= $elements[$j];
20 |         $elements[$j]   ^= $elements[$j-1];
21 |       }
22 |     }
23 |   }
24 | }
25 | 
26 | function comparison_function(&$a, &$b) {
27 |   return $a < $b;
28 | }
29 | 
30 | // Example usage:
31 | $a = array(3, 5, 9, 8, 5, 7, 2, 1, 13);
32 | var_dump($a);
33 | bubble_sort($a); // Sort the elements
34 | var_dump($a);
35 | 


--------------------------------------------------------------------------------
/data_structure/stack/stack_using_class.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Stack implementation using array wrapped in a class.
 4 |  *
 5 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 6 |  *
 7 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
 8 |  * license.
 9 |  */
10 | 
11 | class Stack {
12 |   private $_data;
13 | 
14 |   public function __construct() {
15 |     $this->_data = array();
16 |   }
17 | 
18 |   /**
19 |    * Check whether the stack empty or not.
20 |    *
21 |    * @return bool True if the stack is empty.
22 |    */
23 |   public function is_empty() {
24 |     return empty($this->_data);
25 |   }
26 | 
27 |   public function top() {
28 |     if (!$this->is_empty()) {
29 |       return $this->_data[sizeof($this->_data) - 1];
30 |     } else {
31 |       return null;
32 |     }
33 |   }
34 | 
35 |   /**
36 |    * Push $el into the stack.
37 |    *
38 |    * @param mixed $el Element to be pushed.
39 |    * @return void.
40 |    */
41 |   public function push($el) {
42 |     array_push($this->_data, $el);
43 |   }
44 | 
45 |   /**
46 |    * Pop the top element of the stack.
47 |    *
48 |    * @return mixed $element.
49 |    */
50 |   public function pop() {
51 |     if ($this->top() !== null) {
52 |       return array_pop($this->_data);
53 |     }
54 |     return null;
55 |   }
56 | }
57 | 
58 | // Example usage:
59 | $stack = new Stack();
60 | $stack->push("Element");
61 | $stack->push(23);
62 | $stack->push(array(3, 4, 6));
63 | 
64 | while (!$stack->is_empty()) {
65 |   var_dump($stack->top());
66 |   $stack->pop();
67 | }
68 | 
69 | // Outputs NULL
70 | var_dump($stack->top());
71 | 


--------------------------------------------------------------------------------
/algorithm/sort/quick_sort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Implementation of quick sort sort algorithm in PHP. This code is
 4 |  * direct pseudo-code implementation from Cormen et al book, Introduction
 5 |  * to Algorithms.
 6 |  *
 7 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 8 |  *
 9 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
10 |  * license.
11 |  */
12 | 
13 | /**
14 |  * Assuming $elements is array with numerical-index starting with zero, that's
15 |  * $p, with upper bound index sizeof($elements) - 1, that's $r.
16 |  * @param reference $elements Reference to array element.
17 |  * @param int $p Starting index.
18 |  * @param int $r Pivot index where each element $p to $r - 1 will be compared
19 |  *               against.
20 |  * @return void
21 |  */
22 | function quick_sort(&$elements, $p, $r, $fn = 'comparison_function') {
23 |   if ($p < $r) {
24 |     $q = _partition($elements, $p, $r, $fn);
25 |     quick_sort($elements, $p, $q - 1, $fn);
26 |     quick_sort($elements, $q + 1, $r, $fn);
27 |   }
28 | }
29 | 
30 | function _partition(&$elements, $p, $r, $fn) {
31 |   $x = $elements[$r];
32 |   $i = $p - 1;
33 |   for ($j = $p; $j <= $r - 1; $j++) {
34 |     if ( $fn($elements[$j], $x) ) {
35 |       $i = $i + 1;
36 |       _swap_element($elements[$i], $elements[$j]);
37 |     }
38 |   }
39 |   _swap_element($elements[$i + 1], $elements[$r]);
40 | 
41 |   return $i + 1;
42 | }
43 | 
44 | function _swap_element(&$a, &$b) {
45 |   if ($a != $b) {
46 |     $a ^= $b;
47 |     $b ^= $a;
48 |     $a ^= $b;
49 |   }
50 | }
51 | 
52 | function comparison_function(&$a, &$b) {
53 |   return $a <= $b;
54 | }
55 | 
56 | // Example usage:
57 | $a = array(3, 5, 9, 8, 5, 7, 2, 1, 13);
58 | var_dump($a);
59 | quick_sort($a, 0, sizeof($a) - 1); // Sort the elements
60 | var_dump($a);
61 | 


--------------------------------------------------------------------------------
/algorithm/sort/bucket_sort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Implementation of bucket sort sort algorithm in PHP. This code is
 4 |  * direct pseudo-code implementation from Cormen et al book, Introduction
 5 |  * to Algorithms.
 6 |  *
 7 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 8 |  *
 9 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
10 |  * license.
11 |  */
12 | 
13 | // Using insertion_sort to sort elements in each bucket.
14 | require_once "insertion_sort.php";
15 | 
16 | /**
17 |  * Assuming elements distribution is uniform and in the range 1 - 100 (see line
18 |  * #34 to adjust the range property).
19 |  *
20 |  * @param reference &$elements Reference to array elements.
21 |  * @return void $elements already sorted in place.
22 |  */
23 | function bucket_sort(&$elements) {
24 |   $n = sizeof($elements);
25 |   $buckets = array();
26 | 
27 |   // Initialize the buckets.
28 |   for ($i = 0; $i < $n; $i++) {
29 |     $buckets[$i] = array();
30 |   }
31 | 
32 |   // Put each element into matched bucket.
33 |   foreach ($elements as $el) {
34 |     array_push($buckets[ceil($el/10)], $el);
35 |   }
36 | 
37 |   // Sort elements in each bucket using insertion sort.
38 |   $j = 0;
39 |   for ($i = 0; $i < $n; $i++) {
40 |     // sort only non-empty bucket
41 |     if (!empty($buckets[$i])) {
42 |       insertion_sort($buckets[$i]);
43 | 
44 |       // Move sorted elements in the bucket into original array.
45 |       foreach ($buckets[$i] as $el) {
46 |         $elements[$j++] = $el;
47 |       }
48 |     }
49 |   }
50 | }
51 | 
52 | // Example usage:
53 | // There will be two vardumps called. The first two come from
54 | // insertion_sort.php.
55 | $a = array(31, 40, 9, 1, 18, 3, 20, 14, 6, 10, 8, 13, 22, 23, 29, 30, 55);
56 | var_dump($a);
57 | bucket_sort($a); // Sort the elements
58 | var_dump($a);
59 | 


--------------------------------------------------------------------------------
/data_structure/queue/queue_using_class.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Queue implementation using array wrapped in a class.
 4 |  *
 5 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 6 |  *
 7 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
 8 |  * license.
 9 |  */
10 | 
11 | class Queue {
12 |   private $_queue;
13 | 
14 |   public function __construct() {
15 |     $this->_queue = array();
16 |   }
17 | 
18 |   /**
19 |    * Check whether the queue empty or not.
20 |    *
21 |    * @return bool True if the queue is empty.
22 |    */
23 |   public function is_empty() {
24 |     return empty($this->_queue);
25 |   }
26 | 
27 |   /**
28 |    * Returns the front element in the queue.
29 |    *
30 |    * @return mixed The front element in the queue if exists, otherwise NULL.
31 |    */
32 |   public function front() {
33 |     if (!$this->is_empty()) {
34 |       return $this->_queue[0];
35 |     } else {
36 |       return null;
37 |     }
38 |   }
39 | 
40 |   /**
41 |    * Enqueue $el into the queue.
42 |    *
43 |    * @param mixed $el Element to be enqueued.
44 |    * @return void.
45 |    */
46 |   public function enqueue($el) {
47 |     array_push($this->_queue, $el);
48 |   }
49 | 
50 |   /**
51 |    * Dequeue the front element from the queue.
52 |    *
53 |    * @return mixed $element.
54 |    */
55 |   public function dequeue() {
56 |     if ($this->front() !== null) {
57 |       return array_shift($this->_queue);
58 |     }
59 |     return null;
60 |   }
61 | }
62 | 
63 | // Example usage:
64 | $queue = new Queue();
65 | $queue->enqueue("Element");
66 | $queue->enqueue(23);
67 | $queue->enqueue(array(3, 4, 6));
68 | 
69 | while (!$queue->is_empty()) {
70 |   echo "The front element is now : \n";
71 |   var_dump($queue->front());
72 |   echo "\n";
73 |   $queue->dequeue();
74 | }
75 | 
76 | // Outputs NULL
77 | var_dump($queue->front());
78 | 


--------------------------------------------------------------------------------
/algorithm/sort/radix_sort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Iterative version of radix sort using queues in PHP 
 4 |  * See http://en.wikipedia.org/wiki/Radix_sort#Iterative_version_using_queues.
 5 |  *
 6 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 7 |  *
 8 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
 9 |  * license.
10 |  */
11 | 
12 | /**
13 |  * This is LSD radix sort using queues. Assuming the longest element has
14 |  * 3 digits length.
15 |  *
16 |  * @param reference &$elements Reference to array elements.
17 |  * @return void $elements already sorted in place.
18 |  */
19 | function radix_sort(&$elements) {
20 |   // Array for 10 queues.
21 |   $queues = array(
22 |     array(), array(), array(), array(), array(), array(), array(), array(),
23 |     array(), array()
24 |   );
25 | 
26 |   // Queues are allocated dynamically. In first iteration longest digits
27 |   // element also determined.
28 |   $longest = 0;
29 |   foreach ($elements as $el) {
30 |     if ($el > $longest) {
31 |       $longest = $el;
32 |     }
33 |     array_push($queues[$el % 10], $el);
34 |   }
35 | 
36 |   // Queues are dequeued back into original elements.
37 |   $i = 0;
38 |   foreach ($queues as $key => $q) {
39 |     while (!empty($queues[$key])) {
40 |       $elements[$i++] = array_shift($queues[$key]);
41 |     }
42 |   }
43 | 
44 |   // Remaining iterations are determined based on longest digits element.
45 |   $it = strlen($longest) - 1;
46 |   $d = 10;
47 |   while ($it--) {
48 |     foreach ($elements as $el) {
49 |       array_push($queues[floor($el/$d) % 10], $el);
50 |     }
51 | 
52 |     $i = 0;
53 |     foreach ($queues as $key => $q) {
54 |       while (!empty($queues[$key])) {
55 |         $elements[$i++] = array_shift($queues[$key]);
56 |       }
57 |     }
58 |     $d *= 10;
59 |   }
60 | }
61 | 
62 | // Example usage:
63 | $a = array(170, 45, 75, 90, 802, 24, 2, 66);
64 | var_dump($a);
65 | radix_sort($a);
66 | var_dump($a);
67 | 


--------------------------------------------------------------------------------
/algorithm/sort/insertion_sort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Implementation of insertion sort algorithm in PHP. This code is
 4 |  * direct pseudo-code implementation from Cormen et al book, Introduction
 5 |  * to Algorithms.
 6 |  *
 7 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 8 |  *
 9 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
10 |  * license.
11 |  */
12 | 
13 | /**
14 |  * Assuming $elements is array with numerical-index starting with zero
15 |  * and its size greater than 1.
16 |  * @see http://en.wikipedia.org/wiki/Insertion_sort
17 |  * @param reference $elements Reference to array element.
18 |  * @param string $fn Function used as a comparison function.
19 |  * @returns void $elements already sorted in place.
20 |  */
21 | function insertion_sort(&$elements, $fn = 'comparison_function') {
22 |   if (!is_array($elements) || !is_callable($fn)) return;
23 | 
24 |   for ($i = 1; $i < sizeof($elements); $i++) {
25 |     $key = $elements[$i]; // This will be $a in comparison function.
26 |                           // $key will be the right side element that will be
27 |                           // compared against the left sorted elements. For
28 |                           // min to max sort, $key should be higher than
29 |                           // $elements[0] to $elements[$j]
30 |     
31 | 
32 |     $j = $i - 1; // this will be in $b in comparison function
33 |     while ( $j >= 0 && $fn($key, $elements[$j]) ) {
34 |       $elements[$j + 1] = $elements[$j]; // shift right
35 |       $j = $j - 1;
36 |     }
37 |     $elements[$j + 1] = $key;
38 |   }
39 | }
40 | 
41 | /**
42 |  * Comparison function used to compare each element.
43 |  * @param mixed $a
44 |  * @param mixed $b
45 |  * @returns bool True iff $a is less than $b.
46 |  */
47 | function comparison_function(&$a, &$b) {
48 |   return $a < $b;
49 | }
50 | 
51 | 
52 | // Example usage:
53 | $a = array(3, 5, 9, 8, 5, 7, 2, 1, 13);
54 | var_dump($a);
55 | insertion_sort($a); // Sort the elements
56 | var_dump($a);
57 | 


--------------------------------------------------------------------------------
/algorithm/sort/counting_sort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Implementation of counting sort algorithm in PHP. This code is
 4 |  * direct pseudo-code implementation from Cormen et al book, Introduction
 5 |  * to Algorithms.
 6 |  *
 7 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 8 |  *
 9 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
10 |  * license.
11 |  */
12 | 
13 | /**
14 |  * Assuming each value in the range 0 to $k, and $k = O(n) to be able to sort
15 |  * linearly.
16 |  *
17 |  * @param reference &$elements
18 |  * @param int $k Upper bound value where $k = O(n)
19 |  * @return void
20 |  */
21 | function counting_sort(&$elements, $k) {
22 |   // Place holder for sorted elements
23 |   $sorted_elements = $elements;
24 | 
25 |   // Temporary array
26 |   $temp_elements = array();
27 |   for ($i = 0; $i <= $k; $i++) {
28 |     $temp_elements[$i] = 0;
29 |   }
30 |   for ($i = 0; $i < sizeof($elements); $i++) {
31 |     $temp_elements[$elements[$i]]++;
32 |   }
33 | 
34 |   // After above loop, $temp_elements[$i] now contains number of elements
35 |   // equal to $i. For example :
36 |   //                 index: 0  1  2  3  4  5
37 |   // $elements =      array(1, 1, 0, 0, 3, 1), after the loop :
38 |   //
39 |   //                 index: 0  1  2  3
40 |   // $temp_elements = array(2, 3, 0, 1)
41 |   
42 |   for ($i = 1; $i <= $k; $i++) {
43 |     $temp_elements[$i] += $temp_elements[$i - 1];
44 |   }
45 |   // After above loop, $temp_elements[$i] now contains number of elements
46 |   // less than or equal to $i. For example:
47 |   //                 index: 0  1  2  3
48 |   // $temp_elements = array(2, 3, 0, 1), after the loop :
49 |   //                 index: 0  1  2  3
50 |   // $temp_elements = array(2, 5, 5, 6)
51 | 
52 |   for ($i = sizeof($elements) - 1; $i >= 0; $i--) {
53 |     $sorted_elements[$temp_elements[$elements[$i]] - 1] = $elements[$i];
54 |     $temp_elements[$elements[$i]]--;
55 |   }
56 |   $elements = $sorted_elements;
57 | }
58 | 
59 | // Example usage:
60 | $a = array(3, 5, 9, 8, 5, 7, 2, 1, 13, 2, 2, 4, 3, 1, 6);
61 | var_dump($a);
62 | counting_sort($a, 13); // Sort the elements, k = 13
63 | var_dump($a);
64 | 


--------------------------------------------------------------------------------
/data_structure/linked_list/linked_list_using_spl.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Doubly-linked-list implementation using SPL.
 4 |  *
 5 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 6 |  *
 7 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
 8 |  * license.
 9 |  */
10 | 
11 | /**
12 |  * Extending SplDoublyLinkedList class by providing insert, delete, and search
13 |  * operations.
14 |  */
15 | class LinkedList extends SplDoublyLinkedList {
16 |   public function __construct() {
17 |     $this->push(NULL);
18 |   }
19 | 
20 |   public function insert($el) {
21 |     $this->unshift($el);
22 |   }
23 | 
24 |   public function delete($val) {
25 |     $node = $this->search($val);
26 | 
27 |     if ($node === NULL) return;
28 |     unset($this[$this->key()]);
29 |   }
30 | 
31 |   public function search($val) {
32 |     foreach ($this as $key => $node) {
33 |       if ($node === $val) return $node;
34 |     }
35 |     return $node;
36 |   }
37 | 
38 |   public function getPrev() {
39 |     return ($this->key() - 1) >= 0 ? $this[$this->key() - 1] : 'NULL';
40 |   }
41 | 
42 |   public function getNext() {
43 |     return $this[$this->key() + 1] !== NULL ? $this[$this->key() + 1] : 'NULL';
44 |   }
45 | }
46 | 
47 | $LL = new LinkedList();
48 | $LL->insert("Akeda");
49 | $LL->insert("Dwi");
50 | $LL->insert("Stevey");
51 | $LL->insert("Paul");
52 | 
53 | // Function to test given keyword.
54 | function test_searching($keyword = '') {
55 |   global $LL;
56 | 
57 |   if ($LL->search($keyword) !== NULL) {
58 |     echo "Node with value '$keyword' is found\n";
59 |     echo "The previous node of '$keyword' is : " . $LL->getPrev() . "\n";
60 |     echo "The next node of '$keyword' is : " . $LL->getNext() . "\n";
61 |   } else {
62 |     echo "Node with value '$keyword' is NOT found\n";
63 |   }
64 |   echo "\n";
65 | }
66 | 
67 | // Test searching of node in linked list
68 | test_searching("Akeda");
69 | test_searching("Someone else");
70 | test_searching("Dwi");
71 | test_searching("Paul");
72 | 
73 | // Delete Stevey
74 | $LL->delete("Stevey");
75 | 
76 | // The next and prev references were updated after delete operation.
77 | echo "After 'Stevey' is deleted: \n\n";
78 | test_searching("Dwi");
79 | test_searching("Paul");
80 | 


--------------------------------------------------------------------------------
/algorithm/sort/merge_sort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Implementation of merge sort algorithm in PHP. This code is
 4 |  * direct pseudo-code implementation from Cormen et al book, Introduction
 5 |  * to Algorithms.
 6 |  *
 7 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
 8 |  *
 9 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
10 |  * license.
11 |  */
12 | 
13 |  // Upper bound on each merge operation
14 | define('SENTINEL', 999999999999999999);
15 | 
16 | /**
17 |  * Merge two partitions, left and right, into single sorted parition.
18 |  * @param reference $elements Reference to array element.
19 |  * @param int $p Lower bound index of $elements.
20 |  * @param int $q Middle index of $elements.
21 |  * @param int $r Upper bound index of $elements.
22 |  * @param string $fn Function used as a comparison function.
23 |  */
24 | function _merge(&$elements, $p, $q, $r, $fn = 'comparison_function') {
25 |   $n1 = $q - $p + 1;
26 |   $n2 = $r - $q;
27 | 
28 |   $L = array(); // left partition of $elements
29 |   for ($i = 0; $i < $n1; $i++) {
30 |     $L[$i] = $elements[$p + $i - 1];
31 |   }
32 |   $L[$n1] = SENTINEL;
33 | 
34 |   $R = array(); // right partition of $elements
35 |   for ($i = 0; $i < $n2; $i++) {
36 |     $R[$i] = $elements[$q + $i];
37 |   }
38 |   $R[$n2] = SENTINEL;
39 | 
40 |   $i = 0; $j = 0;
41 |   for ($k = $p; $k <= $r; $k++) {
42 |     if ( call_user_func($fn, $L[$i], $R[$j]) ) {
43 |       $elements[$k-1] = $L[$i];
44 |       $i++;
45 |     } else {
46 |       $elements[$k-1] = $R[$j];
47 |       $j++;
48 |     }
49 |   }
50 | }
51 | 
52 | /**
53 |  * This is the main function to be called if you need to sort array using
54 |  * merget sort algorithm. This function recursively divide the $elements into
55 |  * two portions, half and right, until one partition contains single element.
56 |  * Then it bubble up from bottom to top by merging smaller partition
57 |  * that already sorted into bigger partition. Initial call to this function
58 |  * should be merge_sort($elements, 1, sizeof($elements)).
59 |  * @param reference $elements Reference to array element.
60 |  * @param int $p Lower bound index of $elements.
61 |  * @param int $r Upper bound index of $elements.
62 |  * @param string $fn Function used as a comparison function.
63 |  * @returns void
64 |  */
65 | function merge_sort(&$elements, $p, $r, $fn = 'comparison_function') {
66 |   if ($p < $r) {
67 |     $q = floor(($p + $r) / 2);
68 |     merge_sort($elements, $p, $q);     // left partition
69 |     merge_sort($elements, $q + 1, $r); // right partition
70 |     _merge($elements, $p, $q, $r, $fn); // sort the given elements partition
71 |   }
72 | }
73 | 
74 | function comparison_function(&$a, &$b) {
75 |   return $a <= $b;
76 | }
77 | 
78 | // Example usage:
79 | $a = array(3, 5, 9, 8, 5, 7, 2, 1, 13);
80 | var_dump($a);
81 | merge_sort($a, 1, sizeof($a)); // Sort the elements
82 | var_dump($a);
83 | 


--------------------------------------------------------------------------------
/algorithm/sort/heap_sort.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Implementation of heap sort sort algorithm in PHP. This code is
  4 |  * direct pseudo-code implementation from Cormen et al book, Introduction
  5 |  * to Algorithms.
  6 |  *
  7 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
  8 |  *
  9 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
 10 |  * license.
 11 |  */
 12 | 
 13 | // Global variable to store heap size. Using global variable is not a good
 14 | // practice, the purpose here is for algorithm clarity.
 15 | $_HEAP_SIZE = 0;
 16 | 
 17 | /**
 18 |  * Assuming $elements is array with numerical-index starting with zero
 19 |  * and its size greater than 1.
 20 |  * 
 21 |  * @see http://en.wikipedia.org/wiki/Heapsort
 22 |  * @param reference $elements Reference to array element.
 23 |  * @param string $fn Function used as a comparison function.
 24 |  * @returns void $elements already sorted in place.
 25 |  */
 26 | function heap_sort(&$elements, $fn = 'comparison_function') {
 27 |   global $_HEAP_SIZE;
 28 | 
 29 |   _build_max_heap($elements, $fn);
 30 |   for ($i = sizeof($elements) - 1; $i >= 1; $i--) {
 31 |     // since we're sorting in ascending order,
 32 |     // we swap the highest-value element, that's in first index,
 33 |     // with lowest-value element, that's in last index.
 34 |     _swap_element($elements[0], $elements[$i]);
 35 |     // don't lookup again highest-value element
 36 |     // in [ i .. sizeof($elements) ]
 37 |     $_HEAP_SIZE--;
 38 |     _max_heapify($elements, 0, $fn);
 39 |   }
 40 | }
 41 | 
 42 | /**
 43 |  * Swap element $a and $b.
 44 |  * @param reference &$a Reference to element $a
 45 |  * @param reference &$b Reference to element $b
 46 |  * return void
 47 |  */
 48 | function _swap_element(&$a, &$b) {
 49 |   if ($a != $b) {
 50 |     $a ^= $b;
 51 |     $b ^= $a;
 52 |     $a ^= $b;
 53 |   }
 54 | }
 55 | 
 56 | function _build_max_heap(&$elements, $fn) {
 57 |   global $_HEAP_SIZE;
 58 | 
 59 |   $_HEAP_SIZE = sizeof($elements);
 60 |   $end = floor(sizeof($elements)/2);
 61 |   for ($i = $end; $i >= 0; $i--) {
 62 |     _max_heapify($elements, $i, $fn);
 63 |   }
 64 | }
 65 | 
 66 | /**
 67 |  * Reposition $elements[$i] into correct index based on heap property.
 68 |  * @param reference &$elements Reference to an array
 69 |  * @param int $i Index of particular element.
 70 |  * @return void
 71 |  */
 72 | function _max_heapify(&$elements, $i, $fn) {
 73 |   global $_HEAP_SIZE;
 74 | 
 75 |   $l = _left_child($i);
 76 |   $r = _right_child($i);
 77 |   if ($l < $_HEAP_SIZE && $fn($elements[$l], $elements[$i])) {
 78 |     $largest = $l;
 79 |   } else {
 80 |     $largest = $i;
 81 |   }
 82 |   if ($r < $_HEAP_SIZE && $fn($elements[$r], $elements[$largest])) {
 83 |     $largest = $r;
 84 |   }
 85 |   if ($largest != $i) {
 86 |     _swap_element($elements[$i], $elements[$largest]);
 87 |     _max_heapify($elements, $largest, $fn);
 88 |   }
 89 | }
 90 | 
 91 | /**
 92 |  * Get parent index given node index.
 93 |  * @param int $i Node index
 94 |  * @return int Parent node index
 95 |  */
 96 | function _parent_node($i) {
 97 |   return floor($i/2);
 98 | }
 99 | 
100 | /**
101 |  * Get left child index given node index.
102 |  * @param int $i Node index.
103 |  * @return int Left child index
104 |  */
105 | function _left_child($i) {
106 |   return 2*$i;
107 | }
108 | 
109 | /**
110 |  * Get right child index given node index.
111 |  * @param int $i Node index.
112 |  * @param int Right child index
113 |  */
114 | function _right_child($i) {
115 |   return 2*$i + 1;
116 | }
117 | 
118 | // We use 'greater than' operator for max heap property
119 | // from largest to lowest.
120 | function comparison_function(&$a, &$b) {
121 |   return $a > $b;
122 | }
123 | 
124 | // Example usage:
125 | $a = array(3, 5, 9, 8, 5, 7, 2, 1, 13);
126 | var_dump($a);
127 | heap_sort($a); // Sort the elements
128 | var_dump($a);
129 | 


--------------------------------------------------------------------------------
/data_structure/tree/binary_search_tree.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | class Node {
  4 |   private $_val;
  5 | 
  6 |   /**
  7 |    * Parent's node.
  8 |    * @access private
  9 |    * @type Node
 10 |    */
 11 |   private $_parent;
 12 | 
 13 |   /**
 14 |    * Left-child's node.
 15 |    * @access private
 16 |    * @type Node
 17 |    */
 18 |   private $_left;
 19 | 
 20 |   /**
 21 |    * Right-child's node.
 22 |    * @access private
 23 |    * @type Node
 24 |    */
 25 |   private $_right;
 26 | 
 27 |   public function __construct($el) {
 28 |     $this->_val = $el;
 29 |   }
 30 | 
 31 |   /**
 32 |    * Get node's value.
 33 |    * @access public
 34 |    * @return Node
 35 |    */
 36 |   public function val() {
 37 |     return $this->_val;
 38 |   }
 39 | 
 40 |   /**
 41 |    * Get left-child's node.
 42 |    * @access public
 43 |    * @return Node
 44 |    */
 45 |   public function left() {
 46 |     return $this->_left;
 47 |   }
 48 | 
 49 |   /**
 50 |    * Set left-child's node.
 51 |    * @access public
 52 |    * @return void
 53 |    */
 54 |   public function setLeft(Node $node) {
 55 |     $this->_left = $node;
 56 |   }
 57 | 
 58 |   /**
 59 |    * Get right-child's node.
 60 |    * @access public
 61 |    * @return Node
 62 |    */
 63 |   public function right() {
 64 |     return $this->_right;
 65 |   }
 66 | 
 67 |   /**
 68 |    * Set right-child's node.
 69 |    * @access public
 70 |    * @return void
 71 |    */
 72 |   public function setRight(Node $node) {
 73 |     $this->_right = $node;
 74 |   }
 75 | 
 76 |   /**
 77 |    * Get parent's node.
 78 |    * @access public
 79 |    * @return Node
 80 |    */
 81 |   public function parent() {
 82 |     return $this->_parent;
 83 |   }
 84 | 
 85 |   /**
 86 |    * Set parent's node.
 87 |    * @access public
 88 |    * @return public
 89 |    */
 90 |   public function setParent(Node $node) {
 91 |     $this->_parent = $node;
 92 |   }
 93 | 
 94 |   public function __toString() {
 95 |     return $this->val() === NULL ? 'NULL' : $this->val() . '';
 96 |   }
 97 | }
 98 | 
 99 | class BinarySearchTree {
100 |   private $_root;
101 |   private $_sentinel;
102 | 
103 |   public function __construct() {
104 |     $this->_sentinel = new Node(NULL);
105 | 
106 |     $this->_root = $this->_sentinel;
107 |     $this->_root->setParent($this->_sentinel);
108 |     $this->_root->setLeft($this->_sentinel);
109 |     $this->_root->setRight($this->_sentinel);
110 |   }
111 | 
112 |   public function insert($val) {
113 |     if (!is_object($val) || getclass($val) !== 'Node') {
114 |       $newNode = new Node($val);
115 |     } else {
116 |       $newNode = $val;
117 |     }
118 |     $newNode->setLeft($this->_sentinel);
119 |     $newNode->setRight($this->_sentinel);
120 | 
121 |     $node = $this->_root;
122 |     $parent = $this->_sentinel;
123 |     while ($node !== $this->_sentinel) {    
124 |       $parent = $node;
125 |       if ($newNode->val() < $node->val()) {
126 |         $node = $node->left();
127 |       } else {
128 |         $node = $node->right();
129 |       }
130 |     }
131 | 
132 |     if ($parent === $this->_sentinel) {
133 |       $newNode->setParent($this->_sentinel);
134 |       $this->_root = $newNode;
135 |     } else {
136 |       if ($newNode->val() < $parent->val()) {
137 |         $parent->setLeft($newNode);
138 |       } else {
139 |         $parent->setRight($newNode);
140 |       }
141 |       $newNode->setParent($parent);
142 |     }
143 |   }
144 | 
145 |   public function search($val) {
146 |     $node = $this->_root;
147 | 
148 |     while ($node !== $this->_sentinel && $node->val() !== $val) {
149 |       if ($val < $node->val()) {
150 |         $node = $node->left();
151 |       } else {
152 |         $node = $node->right();
153 |       }
154 |     }
155 |     return $node;
156 |   }
157 | }
158 | 
159 | $BST = new BinarySearchTree;
160 | $BST->insert(15);
161 | $BST->insert(6);
162 | $BST->insert(18);
163 | $BST->insert(3);
164 | $BST->insert(7);
165 | $BST->insert(17);
166 | $BST->insert(20);
167 | $BST->insert(2);
168 | $BST->insert(4);
169 | $BST->insert(13);
170 | $BST->insert(9);
171 | 
172 | function test_searching($num) {
173 |   global $BST;
174 | 
175 |   $node = $BST->search($num);
176 |   if ($node->val() !== NULL) {
177 |     echo "Node with value $num is found\n";
178 |     echo "Parent's node = " . $node->parent() . "\n";
179 |     echo "Left-child's node = " . $node->left() . "\n";
180 |     echo "Right-child's node = " . $node->right() . "\n";
181 |   } else {
182 |     echo "Node with value $num is NOT found\n";
183 |   }
184 |   echo "\n";
185 | }
186 | 
187 | test_searching(7);
188 | test_searching(15);
189 | test_searching(3);
190 | test_searching(2);
191 | 


--------------------------------------------------------------------------------
/data_structure/linked_list/linked_list_using_class.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Doubly-linked-list implementation using class.
  4 |  *
  5 |  * Copyright (c) 2012 Akeda Bagus (admin@gedex.web.id).
  6 |  *
  7 |  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
  8 |  * license.
  9 |  */
 10 | 
 11 | /**
 12 |  * Class wrapper for node in the linked list.
 13 |  */
 14 | class Node {
 15 |   private $_val;
 16 |   private $_prev;
 17 |   private $_next;
 18 | 
 19 |   public function __construct($el) {
 20 |     $this->_val = $el;
 21 |   }
 22 | 
 23 |   public function val() {
 24 |     return $this->_val;
 25 |   }
 26 | 
 27 |   public function next() {
 28 |     return $this->_next;
 29 |   }
 30 | 
 31 |   public function setNext(Node $el) {
 32 |     $this->_next = $el;
 33 |   }
 34 | 
 35 |   public function prev() {
 36 |     return $this->_prev;
 37 |   }
 38 | 
 39 |   public function setPrev(Node $el) {
 40 |     $this->_prev = $el;
 41 |   }
 42 | 
 43 |   public function __toString() {
 44 |     return $this->val() === NULL ? 'NULL' : $this->val();
 45 |   }
 46 | }
 47 | 
 48 | class LinkedList {
 49 |   /**
 50 |    * Head with Node-type object.
 51 |    */
 52 |   private $_head;
 53 | 
 54 |   /**
 55 |    * Dummy Node-type object before the head and after the tail
 56 |    */
 57 |   private $_sentinel;
 58 | 
 59 |   /**
 60 |    * All object initialized with NULL as its head.
 61 |    *
 62 |    * @return void
 63 |    */
 64 |   public function __construct() {
 65 |     // Sentinel is dummy object before head and after tail.
 66 |     $sentinel = new Node(NULL);
 67 |     $sentinel->setNext($sentinel);
 68 |     $sentinel->setPrev($sentinel);
 69 | 
 70 |     $this->_sentinel = $sentinel;
 71 |     $this->_head = $this->_sentinel;
 72 |   }
 73 | 
 74 |   /**
 75 |    * Get dummy object value. It can be anything instead of NULL.
 76 |    */
 77 |   public function sentinelVal() {
 78 |     return $this->_sentinel->val();
 79 |   }
 80 | 
 81 |   /**
 82 |    * Insert $el into the list and make it as a head.
 83 |    *
 84 |    * @param mixed $val
 85 |    * @return void
 86 |    */
 87 |   public function insert($val) {
 88 |     // Make sure element being inserted is type of Node.
 89 |     if (!is_object($val) || getclass($val) !== "Node") {
 90 |       $node = new Node($val);
 91 |     } else {
 92 |       $node = $val;
 93 |     }
 94 | 
 95 |     $this->_head->setPrev($node);
 96 | 
 97 |     $node->setNext($this->_head);
 98 |     $node->setPrev($this->_sentinel);
 99 |     $this->_head = $node;
100 |   }
101 | 
102 |   /**
103 |    * Delete element $el in linked list, if exists.
104 |    *
105 |    * @param mixed $val Element with value $val to be deleted.
106 |    * @return void
107 |    */
108 |   public function delete($val) {
109 |     $node = $this->search($val);
110 | 
111 |     // Sentinel can't be deleted.
112 |     if ($node->val() === $this->sentinelVal()) return;
113 | 
114 |     if ($node->prev()->val() !== $this->sentinelVal()) {
115 |       $node->prev()->setNext($node->next());
116 |     } else {
117 |       $this->_head = $node->next();
118 |     }
119 | 
120 |     if ($node->next() !== $this->sentinelVal()) {
121 |       $node->next()->setPrev($node->prev());
122 |     }
123 |   }
124 | 
125 |   /**
126 |    * Search element in the singly-linked-list.
127 |    *
128 |    * @param mixed $val Element with value $val to be searched.
129 |    * @return Node $el
130 |    */
131 |   public function search($val) {
132 |     $el = $this->_head;
133 |     while ($el->val() !== $this->sentinelVal() && $el->val() !== $val) {
134 |       $el = $el->next();
135 |     }
136 | 
137 |     return $el;
138 |   }
139 | }
140 | 
141 | $LL = new LinkedList();
142 | $LL->insert("Akeda");
143 | $LL->insert("Dwi");
144 | $LL->insert("Stevey");
145 | $LL->insert("Paul");
146 | 
147 | // Function to test given keyword.
148 | function test_searching($keyword = '') {
149 |   global $LL;
150 | 
151 |   $node = $LL->search($keyword);
152 |   if ($node->val() !== $LL->sentinelVal()) {
153 |     echo "Node with value '$keyword' is found\n";
154 |     echo "The previous node of '$keyword' is : " . $node->prev() . "\n";
155 |     echo "The next node of '$keyword' is : " . $node->next() . "\n";
156 |   } else {
157 |     echo "Node with value '$keyword' is NOT found\n";
158 |   }
159 |   echo "\n";
160 | }
161 | 
162 | // Test searching of node in linked list
163 | test_searching("Akeda");
164 | test_searching("Someone else");
165 | test_searching("Dwi");
166 | test_searching("Paul");
167 | 
168 | // Delete Stevey
169 | $LL->delete("Stevey");
170 | 
171 | // The next and prev references were updated after delete operation.
172 | echo "After 'Stevey' is deleted: \n\n";
173 | test_searching("Dwi");
174 | test_searching("Paul");
175 | 


--------------------------------------------------------------------------------