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

<?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);
?>