堆排序和归并排序

堆排序：

package interview.silence;

//最大堆排序
public class HeapSort {
	public static void main(String[] args){
		int[] a= new int[]{5,4,1,3,2,16,9,10,14,8,7};
		
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+",");
		}
		System.out.println();
		heapSort(a);
		
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+",");
		}
	}

	private static void heapSort(int[] a) {    //sort
		buildHeap(a);
//		for(int i=0;i<a.length;i++){
//			System.out.print(a[i]+",");
//		}
//		System.out.println();
		int len = a.length;
		for(int i=a.length-1;i>0;i--){               //从后往前，将最大值放到最后，然后将区间变更为0到len--
			int temp =a[0];
			a[0]=a[i];
			a[i]=temp;
			len--;
			adaptHeap(a,0,len);      //变更之后的堆有可能不是最大堆，进行调整  
		}
	}
	/**
	 * 从第一个非叶子节点开始建堆，
	 * 第一个非叶子节点是length/2;
	 * 一直到第一个元素完结
	 * @param a
	 */
	private static void buildHeap(int[] a) {   //构建堆    
		// TODO Auto-generated method stub
		for(int i=a.length/2;i>=0;i--){
			adaptHeap(a, i, a.length);
		}
	}

	private static void adaptHeap(int[] a, int i, int len) {  //调整堆
		// TODO Auto-generated method stub
		int left = 2*i;        //左儿子
		int right = 2*i+1;      //右儿子
		int max = i;
		if(left<len&&a[left]>a[i]){
			max=left;
		}
		if(right<len&&a[right]>a[max]){
			max=right;
		}
		if(max!=i){
			int temp=a[i];
			a[i]=a[max];
			a[max]=temp;
			adaptHeap(a, max, len);
		}
	}

}

输出 结果为：

5,4,1,3,2,16,9,10,14,8,7,
1,2,3,4,5,7,8,9,10,14,16,
************************************************************************************************

归并排序：

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并操作的工作原理如下：

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

重复步骤3直到某一指针超出序列尾

将另一序列剩下的所有元素直接复制到合并序列尾

代码如下：

package interview.silence;

public class MergeSort {
	/**
	 * 归并排序
	 */
//	private static int[] temp=new int[20];
	public static void main(String[] args){
		int[] a = new int[]{77,56,6,45,89,34,4,7,9};
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+",");
		}
		System.out.println();
		System.out.println("merge:");
		mergeSort(a,0,a.length-1,new int[a.length]);
		
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+",");
		}
	}
	private static void mergeSort(int[] a, int low, int high, int[] temp) {    //递归原理  归并 
		// TODO Auto-generated method stub
		if(low<high){
			int mid = (low+high)/2;
			mergeSort(a, low, mid, temp);
			mergeSort(a, mid+1, high, temp);
			merge(a,low,mid,high,temp);   
		}
		
	}
	/**
	 * 将low-mid 和mid-high这两部分进行归并
	 * @param src
	 * @param low
	 * @param mid
	 * @param high
	 * @param temps
	 */
	private static void merge(int[] src, int low, int mid, int high, int[] temps) {
		// TODO Auto-generated method stub
		int i=low,j=mid+1,k=low;
		while(i<=mid&&j<=high){
			if(src[i]<=src[j])
				temps[k++]=src[i++];
			else
				temps[k++]=src[j++];
		}
		while(i<=mid){
			temps[k++]=src[i++];
		}
		while(j<=high){
			temps[k++]=src[j++];
		}
		for(int index = low;index<=high;index++){
			src[index]=temps[index];
		}
	}
}

输出结果：

77,56,6,45,89,34,4,7,9,

merge:

4,6,7,9,34,45,56,77,89,
稳定排序： 冒泡+插入+归并+基数         不稳定排序：选择+快速+希尔+堆