o(logn)级别的排序算法和php原生sort性能对比

为了和n^级别的算法有一个对比，我把希尔排序的结果页放到了这里。

测试样本为50000

    测试结果

原生sort:0.011001110076904
希尔排序:0.96905589103699
归并排序:0.78104400634766
快速排序:0.53803110122681

快速排序虽然已经足够快了，但是和php的sort还是相差甚远

 

 

以下为测试代码:

/*
 * 检查排序结果是否正确
 * @param array array 测试数据样本
 * @param n int 测试样本数量
 * */
function checkArraySort($array,$n){
    for($i = 0;$i < $n - 1;$i++){
        if($array[$i] > $array[$i + 1]){
            return false;
        }
    }
    return true;
}


/*
 * 希尔排序
 * @param array array 测试数据样本
 * @param n int 测试样本数量
 * */
function shellSort($array,$n){
    $f = 2;
    for($gap = $n / $f;$gap > 0;$gap = intval($gap / $f)){
        for($i = $gap;$i < $n;$i++){
            $j = $i;
            while($j - $gap >= 0 && $array[$j] < $array[$j - $gap]){
                $temp = $array[$j - $gap];
                $array[$j - $gap] = $array[$j];
                $array[$j] = $temp;
                $j -= $gap;
            }
        }
    }
    if(!checkArraySort($array,$n)){
        echo 'shell error';
    }
}

/*
 * 测试排序算法
 * @param functionDesc string 排序函数描述
 * @param functionName string 排序函数名称
 * @param array array 测试数据样本
 * */
function testArray($functionDesc,$functionName,$array){
    $n = count($array);
    $startTime = microtime(true);
    $functionName($array,$n);
    $endTime = microtime(true);
    $time = $endTime - $startTime;
    echo "{$functionDesc}:{$time}<br>";
}

/*
 * 生成测试数据
 * @param arrayNumber int 生成测试数据的数量
 * @param randMin int 生成测试数据的最小值
 * @param randMax int 生成测试数据的最大值
 * @param sort int 是否有序
 * return array
 * */
function generateTestData($arrayNumber,$randMin = 0,$randMax = 0,$sort = 0){
    if($randMax == 0){
        $randMax = $arrayNumber;
    }
    if($sort == 1){
        for($i = 0; $i < $arrayNumber; $i++){
            $array[] = $i;
        }
    }else{
        for($i = 0; $i < $arrayNumber; $i++){
            $array[] = mt_rand($randMin,$randMax);
        }
    }

    return $array;
}

//归并排序
function __merge(&$array,$l,$mid,$r){
    for($k = $l;$k <= $r;$k++){
        $arr[] = $array[$k];
    }
    $i = $l;
    $j = $mid + 1;
    for($k = $l;$k <= $r;$k++){
        if($i > $mid){
            $array[$k] = $arr[$j - $l];
            $j++;
        }elseif($j > $r){
            $array[$k] = $arr[$i - $l];
            $i++;
        }elseif($arr[$i - $l] > $arr[$j - $l]){
            $array[$k] = $arr[$j - $l];
            $j++;
        }else{
            $array[$k] = $arr[$i - $l];
            $i++;
        }
    }
}

function __mergeSort(&$array,$l,$r){
    if($l >= $r){
        return false;
    }
    $mid = intval(($l + $r) / 2);
    __mergeSort($array,$l,$mid);
    __mergeSort($array,$mid + 1,$r);
    __merge($array,$l,$mid,$r);
}

function mergeSort($array,$n){
    __mergeSort($array,0,$n-1);
    if(!checkArraySort($array,$n)){
        echo 'error';
    }
}


//快速排序
//返回p,使得arr[l...p-1] < arr[p];arr[p+1...r] > arr[p]
function __partition(&$array,$l,$r){
    $v = $array[$l];
    $j = $l;
    for($i = $j + 1;$i < $r;$i++){
        if($array[$i] < $v){
            $temp = $array[$j + 1];
            $array[$j + 1] = $array[$i];
            $array[$i] = $temp;
            $j++;
        }
    }
    $temp = $array[$j];
    $array[$j] = $v;
    $array[$l] = $temp;
    return $j;
}

function __quickSort(&$array,$l,$r){
    if($l >= $r){
        return false;
    }
    $p = __partition($array,$l,$r);
    __quickSort($array,$l,$p);
    __quickSort($array,$p + 1,$r);
}

function quickSort($array,$n){
    __quickSort($array,0,$n);
    if(!checkArraySort($array,$n)){
        echo 'error';
    }
}


$array = generateTestData(50000);
$array1 = $array;
$array2 = $array;
$array3 = $array;
testArray("原生sort",'sort',$array);
testArray("希尔排序",'shellSort',$array1);
testArray("归并排序",'mergeSort',$array2);
testArray("快速排序",'quickSort',$array3);