sorting array value without using built in php like sort() etc

Question

<?php
function sortArray() {
    $inputArray = array(8, 2, 7, 4, 5);
    $outArray = array();
    for($x=1; $x<=100; $x++) {
        if (in_array($x, $inputArray)) {
            array_push($outArray, $x);
        }
    }
    return $outArray;
}


$sortArray = sortArray();
foreach ($sortArray as $value) {
    echo $value . "<br />";
}
?>

I have this code but there are two problems

• What if my numbers in array are greater than 100?
• Also, I'd like to see more than one method of sorting

Answer 1

Here is the way of sorting.

<?php

$array=array('2','4','8','5','1','7','6','9','10','3');

echo "Unsorted array is: ";
echo "<br />";
print_r($array);


for($j = 0; $j < count($array); $j ++) {
    for($i = 0; $i < count($array)-1; $i ++){

        if($array[$i] > $array[$i+1]) {
            $temp = $array[$i+1];
            $array[$i+1]=$array[$i];
            $array[$i]=$temp;
        }       
    }
}

echo "Sorted Array is: ";
echo "<br />";
print_r($array);

?>

Answer 2

Most of the other answers use two for loops to sort an array. At first the code seemed fairly straight and even I thought of the same. But then I wanted to investigate further. How efficient is this method? So using an array of 10,000 values, I used the two for loops method and got an execution time of 7.5 seconds

This is way too much. I'm sure PHP can't be this sloppy. So next I tested the in-built PHP rsort() function and got a time of 0.003 seconds.

Some research gave me the answer that PHP uses a quicksort algorithm to sort indexed arrays with a recursive function. I dug deeper and found a few examples of quicksearch for C++, Java etc. So, I replicated them in PHP, as follows:

/*
    The main function that implements QuickSort
    arr --> Array to be sorted,
    low  --> Starting index,
    high  --> Ending index
*/
function quickSort(&$arr, $low, $high)
{
    if ($low < $high)
    {
        /* pi is partitioning index, arr[p] is now
           at right place */
        $pi = partition($arr, $low, $high);
        // Separately sort elements before
        // partition and after partition
        quickSort($arr, $low, $pi - 1);
        quickSort($arr, $pi + 1, $high);
    }
    
    return $arr;
}

function partition (&$arr, $low = 0, $high)
{
    $pivot = $arr[$high];  // pivot
    $i = ($low - 1);  // Index of smaller element
 
    for ($j = $low; $j <= $high-1; $j++)
    {
        // If current element is smaller than or
        // equal to pivot
        if ($arr[$j] <= $pivot)
        {
            $i++;    // increment index of smaller element
            swap($arr[$i], $arr[$j]);
        }
    }
    swap($arr[$i + 1], $arr[$high]);
    return ($i + 1);
}

function swap(&$a, &$b){
    $t = $a;
    $a = $b;
    $b = $t;
}

The time taken by this algorithm came out be: 0.023 seconds. Not as fast as rsort() but satisfactory.

Answer 3

This is my Quicksort algorithm in PHP:

<?php
$array = [1, 4, 3, 5, 9, 6, 1, 6, 4, 1, 1, 4, 5, 6, 6, 7, 2, 1, 4, 0];
$j = count($array);
$t = $j-1;
while($j>=0){
    for ($i=0; $i < $t; $i++) { 
        $aux = $array[$i]; 
        if($array[$i]>$array[$i+1]){
            $array[$i] = $array[$i+1];
            $array[$i+1] = $aux;
        }
    }
    $j--;
}
print_r($array);

Answer 4

Sorting an array without using the built-in method but all the answers use the pre-defined method count.

I am just trying to refactor it. Please find the below answer.

$array = [50,12, 30, 10, 9, 14];
$count = 0;
foreach($array as $elem){
    $count++;
}
for ($i = 0; $i < $count; $i++) {
    for ($j = 0; $j < $count - 1; $j++) {
        if ($array[$j] > $array[$j + 1]) { 
            $temp = $array[$j];
            $array[$j] = $array[$j + 1]; 
            $array[$j +1] = $temp; 
        }
    }
}
print_r($array);