快排 java 和 scala

快排源于分治算法，上代码.

public class QuickSort {
	
	private int[] arr;

	public QuickSort(int[] arr){
		this.arr = arr;
	}
	
	public void quickSort(int low, int high){
		
		if(low > high) return;
		
		int _low = low;
		int _high = high;
		int temp = arr[_low];   //temp 基准数
		
		while(_low < _high){
			while(_low < _high && arr[_high] > temp)_high--; //一定是从右边开始查找
			if(_low < _high){
				arr[_low] = arr[_high];  //将 高位 与 低位 置换，使 < temp 的数在左边
				_low++;
			}
			while(_low < _high && arr[_low] < temp)_low++; //再从左边开始查找
			if(_low < _high){
				arr[_high] = arr[_low]; //将 低位 与 高位 置换，使 > temp 的数在右边
				_high--;
			}
		}
		
		//最终将基准数归位
		arr[_low] = temp;
		
		quickSort(low,_low-1); //递归调用
		quickSort(_low+1,high);
	}
}

 这个代码相差的不是一点两点啊...

scala 的 quickSort ：

<pre name="code" class="java">def qsort(list:List[Int]):List[Int] =  list match {
		case Nil => Nil
		case head::tail => {
			val (smaller,bigger) = tail.partition(_ < head)
			qsort(smaller):::head::qsort(bigger)	
		}
	}

</pre><pre name="code" class="java">测试类：

public class TestMain {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		int[] arr = {78,300,5,110,34,7,9,10,256,248,14};
		
		QuickSort quickSort = new QuickSort(arr);
		quickSort.quickSort(0,arr.length-1);
		
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i] + " ");
		}
	}
}

结果：5 7 9 10 14 34 78 110 248 256 300 

scala 的测试： 

qsort(List(6,4,5,2))