├── .gitignore
├── searching
    └── binary-search.php
└── sorting
    ├── bubble-sort-algorithm.php
    ├── insertion-sort-algorithm.php
    ├── merge-sort-algorithm.php
    └── selection-sort-algorithm.php


/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | .DS_Store
3 | 


--------------------------------------------------------------------------------
/searching/binary-search.php:
--------------------------------------------------------------------------------
 1 | <?php 
 2 | 
 3 | /**
 4 |  * ############################################################################
 5 |  * Implementation of binary search algorithm in PHP
 6 |  * Tobias Baldauf, 20120624
 7 |  */
 8 | 
 9 | 
10 | /**
11 |  * ############################################################################
12 |  * Let's define our data to work with
13 |  */
14 | $haystack = array("a","b","c","d","e","f","i","q","r","s","t","x","y","z");
15 | $needle = "i";
16 | 
17 | /**
18 |  * ############################################################################
19 |  * The nitty gritty
20 |  */
21 | 
22 | $left = 0;
23 | $right = count($haystack);
24 | $haystack_middle = round($right/2, 0, PHP_ROUND_HALF_DOWN);
25 | 
26 | while($haystack[$haystack_middle]!=$needle and $left<$right-1) {
27 |     ++$counter;
28 |     if(strcmp($haystack[$haystack_middle],$needle)>0) {
29 |         $right = $haystack_middle;
30 |         $haystack_middle = $left + round(($right-$left)/2, 0, PHP_ROUND_HALF_DOWN);
31 |     } else {
32 |         $left = $haystack_middle;
33 |         $haystack_middle = $haystack_middle + round(($right-$left)/2, 0, PHP_ROUND_HALF_DOWN);
34 |     }
35 | }
36 | 
37 | if (strcmp($haystack[$haystack_middle],$needle)==0) {
38 |     echo "Found on position $haystack_middle\n";
39 | } else {
40 |     echo "Nothing found\n";
41 | }
42 | 
43 | ?>


--------------------------------------------------------------------------------
/sorting/bubble-sort-algorithm.php:
--------------------------------------------------------------------------------
 1 | <?php 
 2 | 
 3 | /**
 4 |  * ############################################################################
 5 |  * Implementation of Bubble Sort algorithm in PHP
 6 |  * Tobias Baldauf, 20120624
 7 |  *
 8 |  */
 9 | 
10 | 
11 | /**
12 |  * ############################################################################
13 |  * Let's define our data to work with
14 |  */
15 | $data = array(8,4,1,9,5,7,3,2,6,0);
16 | 
17 | 
18 | /**
19 |  * ############################################################################
20 |  * The nitty gritty
21 |  */
22 | 
23 | function bubblesort($data) {
24 |     $data_length = count($data);
25 |     for ($i=0; $i<$data_length; $i++) {
26 |         for ($j=0; $j<$data_length-1-$i; $j++) {
27 |             if ($data[$j+1] < $data[$j]) {
28 |                 $data = swappositions($data, $j, $j+1);
29 |             }
30 |         }
31 |     }
32 |     return $data;
33 | }
34 | 
35 | $data = bubblesort($data);
36 | print_r($data);
37 | 
38 | 
39 | /**
40 |  * ############################################################################
41 |  * Our toolbelt
42 |  */
43 | 
44 | function swappositions($data, $left, $right) {
45 |     $backup_old_data_right_value = $data[$right];
46 |     $data[$right] = $data[$left];
47 |     $data[$left] = $backup_old_data_right_value;
48 |     return $data;
49 | }
50 | 
51 | 
52 | ?>


--------------------------------------------------------------------------------
/sorting/insertion-sort-algorithm.php:
--------------------------------------------------------------------------------
 1 | <?php 
 2 | 
 3 | /**
 4 |  * ############################################################################
 5 |  * Implementation of Insertion Sort algorithm in PHP
 6 |  * Tobias Baldauf, 20120620
 7 |  *
 8 |  */
 9 | 
10 | 
11 | /**
12 |  * ############################################################################
13 |  * Let's define our data to work with
14 |  */
15 | $data = array(8,4,1,9,5,7,3,2,6,0);
16 | 
17 | 
18 | /**
19 |  * ############################################################################
20 |  * The nitty gritty
21 |  */
22 | 
23 | // Let's move through the data left to right (actually 'left but one'), one step at a time
24 | for($i=1; $i<count($data); $i++) {
25 | 
26 | 	// Always compare the bit we're looking at to its next left neighbor, unless we're at the leftmost side of the array
27 | 	for ($j=$i-1; $j>=0; $j--) {
28 | 
29 | 		sleep(1); // this is just so you can see the work in progress
30 | 		$comparisons++;
31 | 
32 | 		// If the left neighbor is actually bigger than our current bit, let's swap them
33 | 		if ($data[$j]>$data[$j+1]) {
34 | 
35 | 			echo "$data[$j] is bigger than ".$data[$j+1]."\n";
36 | 			$data = swappositions($data, $j, $j+1);
37 | 			$swappings++; // count how often we're swapping things around
38 | 
39 | 		} else { // If the left neighbor is smaller, all is well & we'll skip to the next position
40 | 			break;
41 | 		}
42 | 
43 | 	}
44 | 
45 | }
46 | 
47 | // Let's output some friedly info on how we've done at the end
48 | echo "\nI compared data elements $comparisons times.\n";
49 | echo "I executed $swappings swap-operations to sort all data!\n";
50 | echo "Look at the fantastic result:\n";
51 | print_r($data);
52 | 
53 | 
54 | /**
55 |  * ############################################################################
56 |  * Our toolbelt
57 |  */
58 | 
59 | function swappositions($data, $left, $right) {
60 | 	$backup_old_data_right_value = $data[$right];
61 | 	$data[$right] = $data[$left];
62 | 	$data[$left] = $backup_old_data_right_value;
63 | 	return $data;
64 | }
65 | 
66 | 
67 | ?>


--------------------------------------------------------------------------------
/sorting/merge-sort-algorithm.php:
--------------------------------------------------------------------------------
 1 | <?php 
 2 | 
 3 | /**
 4 |  * ############################################################################
 5 |  * Implementation of Mergesort algorithm in PHP
 6 |  * Tobias Baldauf, 20120624
 7 |  */
 8 | 
 9 | 
10 | /**
11 |  * ############################################################################
12 |  * Let's define our data to work with
13 |  */
14 | $data = array(8,4,1,9,5,7,3,2,6,0);
15 | 
16 | 
17 | /**
18 |  * ############################################################################
19 |  * The nitty gritty
20 |  */
21 | 
22 | // This is it! Get the data to process, split it into halfs and compare
23 | // Returns: freshly sorted, reassembled array from split array-parts
24 | function mergesort($data) {
25 | 
26 |     // Only process if we're not down to one piece of data
27 |     if(count($data)>1) {
28 |         
29 |         // Find out the middle of the current data set and split it there to obtain to halfs
30 |         $data_middle = round(count($data)/2, 0, PHP_ROUND_HALF_DOWN);
31 |         // and now for some recursive magic
32 |         $data_part1 = mergesort(array_slice($data, 0, $data_middle));
33 |         $data_part2 = mergesort(array_slice($data, $data_middle, count($data)));
34 | 
35 |         // Setup counters so we can remember which piece of data in each half we're looking at
36 |         $counter1 = $counter2 = 0;
37 | 
38 |         // iterate over all pieces of the currently processed array, compare size & reassemble
39 |         for ($i=0; $i<count($data); $i++) {
40 |             // if we're done processing one half, take the rest from the 2nd half
41 |             if($counter1 == count($data_part1)) {
42 |                 $data[$i] = $data_part2[$counter2];
43 |                 ++$counter2;
44 |             // if we're done with the 2nd half as well or as long as pieces in the first half are still smaller than the 2nd half
45 |             } elseif (($counter2 == count($data_part2)) or ($data_part1[$counter1] < $data_part2[$counter2])) { 
46 |                 $data[$i] = $data_part1[$counter1];
47 |                 ++$counter1;
48 |             } else {
49 |                 $data[$i] = $data_part2[$counter2];
50 |                 ++$counter2;
51 |             }
52 |         }
53 |     }
54 |     return $data;
55 | }
56 | 
57 | // Initiate the recursive magic by calling the function once & print the output for our viewing pleasure 
58 | $data = mergesort($data);
59 | print_r($data);
60 | 
61 | 
62 | ?>


--------------------------------------------------------------------------------
/sorting/selection-sort-algorithm.php:
--------------------------------------------------------------------------------
 1 | <?php 
 2 | 
 3 | /**
 4 |  * ############################################################################
 5 |  * Implementation of Selection Sort algorithm in PHP
 6 |  * Tobias Baldauf, 20120621
 7 |  *
 8 |  */
 9 | 
10 | 
11 | /**
12 |  * ############################################################################
13 |  * Let's define our data to work with
14 |  */
15 | $data = array(8,4,1,9,5,7,3,2,6,0);
16 | 
17 | 
18 | /**
19 |  * ############################################################################
20 |  * The nitty gritty
21 |  */
22 | 
23 | // Let's move through the data
24 | for($i=0; $i<count($data)-1; $i++) {
25 | 	$min = $i;
26 | 	for($j=$i+1; $j<count($data); $j++) {
27 | 		if ($data[$j]<$data[$min]) {
28 | 			echo "$data[$j] is smaller than ".$data[$i]."\n";
29 | 			$min = $j;
30 | 		}
31 | 	}
32 |     $data = swappositions($data, $i, $min);
33 | }
34 | 
35 | echo "\n\nResult:";
36 | print_r($data);
37 | 
38 | 
39 | /**
40 |  * ############################################################################
41 |  * Our toolbelt
42 |  */
43 | 
44 | function swappositions($data, $left, $right) {
45 | 	$backup_old_data_right_value = $data[$right];
46 | 	$data[$right] = $data[$left];
47 | 	$data[$left] = $backup_old_data_right_value;
48 | 	return $data;
49 | }
50 | 
51 | 
52 | ?>


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