写一个快排序，堆排序需要多少时间？

排序，作为计算机算法的基础知识之一，是每个程序员必备的技能之一，也许你不经常自己写排序，但是，如果自己写，试试需要多长时间，完整，正确的写好排序了？最简单的莫过于冒泡，选择排序。说白了，排序，莫过于三部走，一是如何遍历，二是比较，三是交换。其中遍历是关键！

　　下面，对常用的快排序和堆排序进行实现，争取5分钟只能完成一个算法的书写。天下武功，唯快不破！快速实现而熟练的实现是一个程序员基本功底的体现。

如何最简单，最快，而正确的实现了？那就是对10以内的整数排序，是最快的，最能看到效果的。首先了明确输入和输出。记住快排序的思想是找一个标杆，让后左右开工，分别找比标杆大小的进行交换。确定新的区间，然后递归实现。话不多说，开始：需要设计两个方法，一个实现一趟的操作，一个递归调用，完事。一下为java实现：（只要思路清晰，什么语言实现都无关紧要啦！）计时开始！

/**
* filename：TestQuickSortS.java
* CopyRight：
* Date：2013-11-21
* Copyright JanneLee Corporation 2013
* Copyright
* version 1.0
*/

package com.lee.sort;

/**
* Description：
* @author: JanneLee@gmail.com
* @date:2013-11-21 下午02:03:47
* @version:1.0
*/

public class TestQuickSortS {
private int Partion(int arr[],int low,int high){
int pivotkey=arr[low];
while(low<high){
while(low<high&&arr[high]>=pivotkey){
--high;
}
arr[low]=arr[high];
while(low<high&&arr[low]<=pivotkey){
++low;
}
arr[high]=arr[low];
}
arr[low]=pivotkey;
return low;
}

public void  QuickSort(int arr[],int low,int high) {
if(low<high){
int pivot=Partion(arr, low, high);
QuickSort(arr, low, pivot-1);
QuickSort(arr,pivot+1,high);
}
}
/**
*Description：[the test code]
*@author: JanneLeeMAC@gmail.com
*@date:2013-11-21 下午02:09:36
*@version: 1.0
*/
public static void  main(String args[]) {
int arr[]={2,3,1,4,5};
TestQuickSortS s = new TestQuickSortS();
s.QuickSort(arr, 0, arr.length-1);
for(int i=0;i<arr.length;++i){
System.out.print(arr[i]+" ");
}
}
}

事实证明，这次没有超过5分。nice啊，不过，只能对整数排序，似乎不太爽，还有浮点，字符串等等啊。c++中有模板非常的棒，java中可以借助泛型，不过java中有Object类，还有一个非常爽的Compareable接口，好了，有了比较的工具。那就再改进一下比较方式呗。动手：

package com.lee.sort;

public class TestQuickSort {
@SuppressWarnings("unchecked")
private static int Partion(Object [] arr,int low,int high){
Object pivotkey=arr[low];
while(low<high){
while(low<high&&((Comparable<Object>)arr[high]).compareTo((Comparable<Object>)pivotkey)>=0){
--high;
}
arr[low]=arr[high];
while(low<high&&((Comparable<Object>)pivotkey).compareTo((Comparable<Object>)arr[low])>=0){
++low;
}
arr[high]=arr[low];
}
arr[low]=pivotkey;
return low;
}

public static void QuickSort(Object arr[],int low,int high){
if(low<high){
int pivot=Partion(arr, low, high);
QuickSort(arr, low, pivot-1);
QuickSort(arr, pivot+1, high);
}
}

public static void main(String args[]){
Object arr[]={1,3,4,2,0,-5,6,7};
//        Object arr[]={1.1,3.3,4.2,2.2,0.1,-5.0,6.99999,7.0};
//        Object arr[]={"how","are","you","i","am","fine","thanks","!"};
//        Object arr[]={"123","432","213","124","a123","432","23412","adfa"};
QuickSort(arr,0,arr.length-1);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
}

　　这次感觉是不是更爽了啊，哈哈。那就接着开始堆。基本的思想也是一样的，先简单写出来，再进行调整，堆是一颗完全二叉树。比较的规则是老子比两个儿子都大，或者老子比两个儿子都小。主要是遍历的技巧性。要先知道怎么调整一个堆，然后开始构造，不断的调整。也就是一个调整的方法，一个构造的方法，话不多说，开始：

package com.lee.sort;

public class TestHespSortS {
private void HeapAdjust(int arr[],int start,int end){
int temp=arr[start];
int i=2*start+1;
while(i<=end-1){
if(i<end-1&&arr[i]<arr[i+1]){
++i;
}
if(i<end-1&&temp<arr[i]){
arr[start]=arr[i];
start=i;
i=start+1;
}else {
break;
}
}
arr[start]=temp;
}
public void HeapSort(int arr[]) {
int len=arr.length;
for(int i=(len>>1)-1;i>=0;--i){
HeapAdjust(arr, i,len);
}
int temp=0;
while(len>0){
temp=arr[0];
arr[0]=arr[len-1];
arr[len-1]=temp;
HeapAdjust(arr, 0, --len);
}
}
public static void main(String sags[]){
int arr[]={1,3,2,4,6,5};
TestHespSortS s = new TestHespSortS();
s.HeapSort(arr);

for(int i=0;i<arr.length;++i){
System.out.print(arr[i]+" ");
}
}
}

丫的，堆排序就是麻烦，都写了10几分钟。主要是各种边界的问题。同样，写出适合跟多种类的堆排序。如下：

package com.lee.sort;

public class TestHeapSort{
public static void main(String args[]){
Object arr[]={1,3,4,2,6,-5,6,7};  //最开始测试数组
//         Object arr[]={1.1,3.1,4.0,2.5,6.2,-5.2,6.2,7.2};  //最开始测试数组
//         Object arr[]={"we","are","the","best","one","In","the","china"};  //最开始测试数组

HeapSort(arr);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}

}
@SuppressWarnings("unchecked")
public static void HeapAdjust(Object []arr,int start,int end){
Object temp=arr[start];
int i=2*start+1;
while(i<=end-1){
if(i<end-1&&((Comparable<Object>)arr[i]).compareTo((Comparable<Object>)arr[i+1])<0){
++i;
}
if(((Comparable<Object>)temp).compareTo(((Comparable<Object>)arr[i]))<0){
arr[start]=arr[i];
start=i;
i=2*start+1;
}else{
break;
}
}
arr[start]=temp;
}

public static void  HeapSort(Object []arr) {
int n=arr.length;
for(int i=(n/2-1);i>=0;i--){
HeapAdjust(arr, i, n);
}
Object tempObject=null;
while(n>0){
tempObject=arr[0];
arr[0]=arr[n-1];
arr[n-1]=tempObject;
HeapAdjust(arr, 0, --n);
}
}
}

要牛，无他，但手熟尔。