内部排序小结（策略模式实现）

<?php

/**

 * 内部排序：将待排序序列放在内存中排序，适合于不太大的序列

 */



/*

 * 策略模式实现如下

 */



//排序接口

interface Isort{

	public function inSort($arr);

}



/*================冒泡排序=====================*/

/*冒泡排序：时间复杂度O(n^2),稳定排序*/



class BubbleSort implements Isort{

	

	public function inSort($arr){

		$len = count($arr);

		for ($i=0;$i<$len-1;$i++){

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

				if($arr[$j]>$arr[$j+1]){

					$tmp = $arr[$j];

					$arr[$j] = $arr[$j+1];

					$arr[$j+1] = $tmp;

				}

			}

		}

		return $arr;

	}

	

}



//冒泡的改进算法

class BubbleSortB implements Isort{

	

	public function inSort($arr){

		$len = count($arr);

		for ($i=0;$i<$len-1;$i++){

			$flag = 1;

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

				if($arr[$j]>$arr[$j+1]){

					$flag = 0;

					$tmp = $arr[$j];

					$arr[$j] = $arr[$j+1];

					$arr[$j+1] = $tmp;

				}

			}

			if($flag==1)break;

		}

		return $arr;

	}

	

}



//沉底，往下沉

class BubbleSortA implements Isort{

	

	public function inSort($arr){

		$len = count($arr);

		for ($i=0;$i<$len-1;$i++){

			for($j=$len-1;$j>$i;$j--){

				if($arr[$j]>$arr[$j-1]){

					$tmp = $arr[$j];

					$arr[$j] = $arr[$j-1];

					$arr[$j-1] = $tmp;

				}

			}

		}

		return $arr;

	}

	

}

/*======================END===========================*/









/*======================选择排序=====================*/





//选择排序，时间复杂度O(n^2)，不稳定的

class SelectSort implements Isort{

	

	public function inSort($arr){

		$len = count($arr);

		for($i=0;$i<$len-1;$i++){

			$k = $i;

			for($j=$i+1;$j<$len;$j++){

				if($arr[$j]<$arr[$k]){

					$k = $j;

				}

			}

			if($k!=$i){

				$tmp = $arr[$k];

				$arr[$k] = $arr[$i];

				$arr[$i] = $tmp;

			}

		}

		return $arr;

	}

}

/*==================END===================*/









/*=======================快速排序==========================*/

//不稳定的，时间复杂度理想O(n*logn),最坏O(n^2)

class QuickSort implements Isort{

	public function inSort($arr){

		$len = count($arr);

		if($len <= 1){//注意退出条件，不止等于1，小于1 同样考虑

			return $arr;

		}

		$key = $arr[0];

		$left_arr = array();

		$right_arr = array();

		for ($i=1;$i<$len;$i++){

			if($arr[$i]>$key){

				$right_arr[] = $arr[$i];

			}else{

				$left_arr[] = $arr[$i];

			}

		}

		$res = array_merge($this->inSort($left_arr),array($key),$this->inSort($right_arr));

		return $res;

	}

}

/*=========================END==============================*/





/**

 * 插入排序，稳定的，时间复杂度O(n^2)

 */



class InsertSort implements Isort{

	public function inSort($arr){

		$len = count($arr);

		for($i=1;$i<$len;$i++){

			$tmp = $arr[$i];

			$key = $i-1;

			while($key>=0&&$tmp<$arr[$key]){//条件顺序不能颠倒

				$arr[$key+1] = $arr[$key];

				$key--;

			}

			$arr[$key+1] = $tmp;

		}

		return $arr;

	}

}







/**

 * 

 *希尔排序，不稳定的，时间复杂度O（n^1.5）

*/

class ShellSort implements Isort{

	public function inSort($arr){

		$len = count($arr);

		$dk = floor($len/2);//初始跨度

		while($dk>0){

			for($i=$dk;$i<$len;$i++){

				$tmp = $arr[$i];

				$key = $i-$dk;

				while ($key>=0&&$tmp<$arr[$key]){//每次在跨度分组内进行直接插入排序

					$arr[$key+$dk] = $arr[$key];

					$key = $key-$dk;

				}

				$arr[$key+$dk] = $tmp;

			}

			

			$dk = floor($dk/2);

			

		}

		return $arr;

	}

}









/**

 * 堆排序：不稳定的，时间复杂度O(n*logn)

 * 

 */

class HeapSort implements Isort{

	public function inSort($arr){

		$len = count($arr);

		$this->initHeap($arr);

		

		for($end=$len-1;$end>0;$end--){

			$tmp = $arr[$end];

			$arr[$end] = $arr[0];

			$arr[0] = $tmp;

			

			$this->adjustHeap($arr,0,$end-1);

		}

		return $arr;

	}

	

	private function initHeap(&$arr){

		$len = count($arr);

		for($start=floor($len/2)-1;$start>=0;$start--){

			$this->adjustHeap($arr,$start,$len-1);

		}

	}

	

	private function adjustHeap(&$arr,$start,$end){

		$max = $start;

		$lchild = 2*($start+1)-1;

		$rchild = 2*($start+1);

		

		if($lchild<=$end){

			if($arr[$lchild]>$arr[$max]){

				$max = $lchild;

			}

			if($rchild<=$end&&$arr[$rchild]>$arr[$max]){

				$max = $rchild;

			}

		}

		

		if($max!=$start){

			$tmp = $arr[$max];

			$arr[$max] = $arr[$start];

			$arr[$start] = $tmp;

			

			$this->adjustHeap($arr, $max, $end);

		}

	}

}







/**

 * 归并排序：稳定的，时间复杂度O(n*logn)，最好，最坏都是这个

 */



class MergeSort implements Isort{

	public function inSort($arr){

		$len = count($arr);

		$this->mSort($arr,0,$len-1);

		return $arr;

	}

	

	//核心，对数组中某一段进行排序

	private function mSort(&$arr,$low,$high){

		if($low<$high){

			$mid = floor(($low+$high)/2);

			$this->mSort($arr, $low, $mid);

			$this->mSort($arr, $mid+1, $high);

			$this->mergeArray($arr, $low, $mid, $high);

		}

	}

	

	private function mergeArray(&$arr,$low,$mid,$high){

		$i = $low;

		$j = $mid+1;

		while ($i<=$mid&&$j<=$high){

			if($arr[$i]<$arr[$j]){

				$tmp[] = $arr[$i++];

			}else{

				$tmp[] = $arr[$j++];

			}

		}

		while($i<=$mid){

			$tmp[] = $arr[$i++];

		}

		while($j<=$high){

			$tmp[] = $arr[$j++];

		}

		

		$len = count($tmp);

		for($k=0;$k<$len;$k++){

			$arr[$low+$k] = $tmp[$k];

		}

	}

}













class Context{

	public $method;

	

	public function __construct(Isort $method){

		$this->method = $method;

	}

	

	public function doSort($arr){

		$arr = $this->method->inSort($arr);

		return $arr;

	}

}

$arr = array(6,3,1,2,7,4,5,0,-2,-1,0);

$m = new context(new MergeSort());

$arr = $m->doSort($arr);

print_r($arr);

?>