PHP九大算法

<?php

class Algorithm
{
    /**
     * @param $arr
     * @return mixed
     * 选择排序
     */
    function selectionSort($arr)
    {
        $len = count($arr);
        if ($len == 0 || !is_array($arr)) {
            return [];
        }
        for ($i = 0; $i < $len - 1; $i++) {
            $min_key = $i;
            for ($j = $i + 1; $j < $len; $j++) {
                if ($arr[$min_key] > $arr[$j]) {
                    $min_key = $j;
                }
            }
            if ($min_key != $i) {
                $tmp_val       = $arr[$min_key];
                $arr[$min_key] = $arr[$i];
                $arr[$i]       = $tmp_val;
            }
        }

        return $arr;
    }


    /**
     * @param $arr
     * @return array
     * 插入排序
     */
    function insertSort2($arr)
    {
        $len = count($arr);
        if ($len == 0 || !is_array($arr)) {
            return [];
        }
        for ($i = 0; $i < $len - 1; $i++) {
            for ($j = $i + 1; ($j >= 0) && ($arr[$j] < $arr[$j - 1]); $j--) {
                $tmp         = $arr[$j];
                $arr[$j]     = $arr[$j - 1];
                $arr[$j - 1] = $tmp;
            }
        }
        return $arr;
    }

    /**
     * @param $arr
     * @return array
     * 插入排序
     */
    function insertSort($arr)
    {
        $len = count($arr);
        if ($len == 0 || !is_array($arr)) {
            return [];
        }
        for ($i = 1; $i < $len; $i++) {
            $tmp_val = $arr[$i];
            for ($j = $i - 1; ($j >= 0) && ($tmp_val < $arr[$j]); $j--) {
                $arr[$j + 1] = $arr[$j];
                $arr[$j]     = $tmp_val;
            }
        }
        return $arr;
    }


    /**
     * @param $arr
     * 堆排序
     */
    //

    
	$array = [2,5,21,4,77,8,999,66];
	$array = adjustMaxHeap($array);
	$len = count($array);
	$length = $len;
	for ($i = 0; $i < $length; $i++) {
		$array = swap($array,0,$len-1);
		$len--;
		adjust($array, $len, 0);
	}
	print_r($array);



	function adjustMaxHeap($array) {
		$len = count($array);
		$lastParentNode = floor($len/2);
		for($i = $lastParentNode; $i>=0; $i--) {
			adjust($array, $len, $i);
		}
		return $array;
	}

	
	function adjust(&$array, $len, $i) {
		$left  = 2 * $i + 1;
		$right = 2 * $i + 2;
		$largest = $i;
		if (($left < $len) && ($array[$left] < $array[$largest])){
			$largest = $left;
		}
		if (($right < $len) && ($array[$right] < $array[$largest])){
			$largest = $right;
		}
		
		if ($i != $largest) {
			$array = swap($array, $largest, $i);
			adjust($array, $len, $largest);
		}
	}
	

	function swap($array, $a, $b) {
		$tmp = $array[$a];
		$array[$a] = $array[$b];
		$array[$b] = $tmp;
		return $array;
	}




    //

    /**
     * @param $arr
     * @return array
     * 冒泡排序
     */
    function bubbleSort($arr)
    {
        $len = count($arr);
        if ($len == 0 || !is_array($arr)) {
            return [];
        }
        for ($i = 0; $i < $len - 1; $i++) {
            for ($j = $len - 1; $j > $i; $j--) {
                if ($arr[$j] < $arr[$j - 1]) {
                    $tmp_val     = $arr[$j];
                    $arr[$j]     = $arr[$j - 1];
                    $arr[$j - 1] = $tmp_val;
                }
            }
        }
        return $arr;
    }

    //最好时间N 最差N
   function  bestPao($array)
{
	$len = count($array);
	if ($len > 0) {
		$is_swap = 0;
		for ($i = 0; $i < $len-1; $i++) {
			for ($j = 0; $j<$len-1; $j++) {
				if ($array[$j+1] < $array[$j]) {
					$is_swap = 1;
					$tmp = $array[$j+1];
					$array[$j+1] = $array[$j];
					$array[$j] = $tmp;
				}
			}
			if ($is_swap == 0) {
				return $array;
			}
		}
	}
	return $array;
}
	
    /**
     * @param $arr
     * @return array
     * 快速排序
     * 一定要注意边界值
     */
    function quickSort($arr)
    {
        $len = count($arr);
        if ($len <= 1 || !is_array($arr)) {
            return $arr;
        }
        $target = $arr[0];
        $right  = [];
        $left   = [];
        for ($i = 1; $i < $len; $i++) {
            if ($arr[$i] >= $target) {
                $right[] = $arr[$i];
            } else {
                $left[] = $arr[$i];
            }
        }
        $left    = $this->quickSort($left);
        $right   = $this->quickSort($right);
        $new_arr = array_merge($left, [$target], $right);
        return $new_arr;
    }


/
    /**
     * @param $arr
     * @return array
     * 二路归并排序
     * 关键字 分两路,排序,递归
     */
    function mergeSort($arr)
    {
        $len = count($arr);
        if ($len <= 1 || !is_array($arr)) {
            return $arr;
        }

        $slen  = intval($len / 2);
        $left  = array_slice($arr, 0, $slen);
        $right = array_slice($arr, $slen);
        return $this->merge($this->mergeSort($left), $this->mergeSort($right));
    }

    function merge($a, $b)
    {
        $len_a = count($a);
        $len_b = count($b);
        $ret   = [];
        $i     = 0;
        $j     = 0;
        while ($i < $len_a || $j < $len_b) {
            if (isset($a[$i]) && isset($b[$j])) {
                if ($a[$i] > $b[$j]) {
                    $ret[] = $b[$j];
                    $j++;
                } else {
                    $ret[] = $a[$i];
                    $i++;
                }
            } elseif (isset($a[$i])) {
                $ret[] = $a[$i];
                $i++;
            } elseif (isset($b[$j])) {
                $ret[] = $b[$j];
                $j++;
            }
        }
        return $ret;
    }


    /**
     * @param $arr
     * @return array
     * 桶排序
     */
    function bucketSort($arr)
    {
        $len = count($arr);
        if ($len <= 1 || !is_array($arr)) {
            return $arr;
        }
        $min_val = min($arr);
        $max_val = max($arr);
        $ret_array = array_fill($min_val, $max_val-$min_val+1, 0);
        foreach ($arr as $val) {
            $ret_array[$val]++;
        }
        $ret = [];
        foreach ($ret_array as $key=>$val) {
            while ($val > 0) {
                $ret[] = $key;
                $val--;
            }
        }
        return $ret;
    }


    /**
     * @param $arr
     * @return array
     * 基数排序
     */
    function radix($arr)
    {
        $len = count($arr);
        if ($len <= 1 || !is_array($arr)) {
            return $arr;
        }
        $max_val = max($arr);
        $radix_len = strlen($max_val);
        $mod_val = 10;
        $dev_val = 1;
        for ($i=1; $i<=$radix_len; $i++) {
            $arr = $this->radixOrder($arr, $mod_val, $dev_val);
            $dev_val *= 10;
        }
        return $arr;
    }

    function radixOrder($arr, $mod_val, $dev_val)
    {
        $ret_array = array_fill(0, 10, []);
        $len = count($arr);
        for ($i = 0; $i < $len; $i++) {
            $tmp_val = intval($arr[$i] / $dev_val) % $mod_val;
            $ret_array[$tmp_val][] = $arr[$i];
        }
        $ret = [];
        foreach ($ret_array as $key=>$val) {
            foreach ($val as $item) {
                $ret[] = $item;
            }
        }
        return $ret;
    }


    /**
     * @param $arr
     * 希尔排序
     */
    function shellSort($arr) {
        $len = count($arr);
        if ($len <= 1 || !is_array($arr)) {
            return $arr;
        }
        $inc = floor($len / 3) + 1;
        //$inc = intval($len / 2);
        for ($i = $inc; $i>0; $i = intval($i / 3)) {
            for ($j = 0; $j<$len; $j++) {
                $k = 0;
                while ($k < $len) {
                    if ((($k+$i) < $len) && ($arr[$k] > $arr[$k+$i])) {
                        $tmp_val = $arr[$k];
                        $arr[$k] = $arr[$k+$i];
                        $arr[$k+$i] = $tmp_val;
                    }
                    $k = $k+$i;
                }
            }
        }
        return $arr;
    }
}


//sort
$al  = new NewSale();
$arr = [33, 1, 44, 99, 66, 55, 44, 22, 77, 88, 11];
//选择排序;
//$ret = $al->selectionSort($arr);
//print_r($ret);
//插入排序
//$ret = $al->insertSort($arr);
//print_r($ret);
//堆排序
//$ret = $al->heapSort($arr);
//print_r($ret);
//冒泡排序
//$ret = $al->heapSort($arr);
//print_r($ret);
//快速排序
//$ret = $al->quickSort($arr);
//print_r($ret);
//$ret = $al->mergeSort($arr);
//print_r($ret);
//$ret = $al->bucketSort($arr);
//print_r($ret);
//$ret = $al->radix($arr);
//print_r($ret);

$ret = $al->shellSort($arr);
print_r($ret);