几种排序算法JAVA代码

堆排序：

public class heapSort {
	public void maxHeapDown(int[] arr,int currentHeap,int end){
		int left=currentHeap*2+1,right=currentHeap*2+2;
		int maxHeap;//保存当前节点的子节点中比自己大的节点的下标
		if(right == end){//最后一个非根节点只有左子节点
			if(arr[left] > arr[currentHeap]){
				int temp = arr[left];
				arr[left] = arr[currentHeap];
				arr[currentHeap] = temp;
			}
		}
		else{//最后一个非根节点有左右子节点  
			if(arr[left] > arr[right]){
				maxHeap=left;
			}else{
				maxHeap=right;
			}
			if(arr[currentHeap] < arr[maxHeap]){
				int temp=arr[currentHeap];
				arr[currentHeap] = arr[maxHeap];
				arr[maxHeap]=temp;
				if(maxHeap < end/2-1){
					maxHeapDown(arr,maxHeap,end);
				}
			}
		}
	}
	public void adjustHeap(int[] arr,int end){//将数组调整为一个大根堆
		int mid=end/2-1;
		int currentHeap=mid;
		while(currentHeap >= 0){
			maxHeapDown(arr, currentHeap,end);
			currentHeap--;
		}
	}
	
	public void HeapSortAsc(int[] arr){//将数组按升序排序
		int end=arr.length;
		for(int i=0;i < arr.length-1;i++){
			adjustHeap(arr,end);
			int temp=arr[0];
			arr[0]=arr[end-1];
			arr[end-1]=temp;
			end--;
		}
	}
}

快速排序：

<pre name="code" class="java">public class Qsort {
	 public void QSort(int[] arr,int head,int tail){
		int pivotKey;//枢轴变量
	    	pivotKey=arr[head];
	    	int initHead=head,initTail=tail;
	    	//int head=0,tail=arr.length-1;
	    	while(head < tail){
	    		while(head < tail && arr[tail] >= pivotKey )tail--;
	    		arr[head]=arr[tail];
	    		while(head < tail && arr[head] <= pivotKey )head++;
	    		arr[tail]=arr[head];
	    	}
	    	arr[head]=pivotKey;
	    	if(initHead < head-1)
	    		QSort(arr,initHead,head-1);
	    	if(tail+1 < initTail)
	    		QSort(arr,tail+1,initTail);
	    }
}

归并排序：

<pre name="code" class="java">public class MergingSort {//归并排序JAVA实现
	
	/*合并两个相邻区域
	 * start -- 第1个有序区间的起始地址。
	 * mid   -- 第1个有序区间的结束地址。也是第2个有序区间的起始地址。
	 * end   -- 第2个有序区间的结束地址。
    <span style="white-space:pre">	</span>*/
	public void merge(int[] arr,int star,int mid,int end){
		int[] temp=new int[end-star+1];
		int i=star,j=mid+1,k=0;
		
		while(i<=mid && j<=end){
			if(arr[i] < arr[j])
				temp[k++]=arr[i++];
			else
				temp[k++]=arr[j++];
		}
		while(i <= mid){
			temp[k++]=arr[i++];
		}
		while(j <= end){
			temp[k++]=arr[j++];
		}
		
		for(i=0;i < temp.length;i++){
			arr[star+i]=temp[i];
		}
		temp=null;
	}
	
	public void mergeGroups(int[] arr,int len,int gap){
		int i;
		for(i=0;i+gap*2-1 < len;i+=(gap*2)){
			merge(arr,i,i+gap-1,i+gap*2-1);
		}
		if(i+gap-1<len-1)
			merge(arr,i,i+gap-1,len-1);
	}
	
	public void mergeSortDown2Up(int[] arr){
		if(arr==null)
			return ;
		for(int i=1;i < arr.length;i*=2){
			mergeGroups(arr, arr.length, i);
		}
	}
}

总结：从平均时间来看，快速排序最佳，但快速排序在最坏情况下的时间性能不如堆排序和归并排序。后两者相比较时，若待排序数组较大则归并排序所需时间较小但它所需辅助存取空间较大