java 排序算法

import java.util.Arrays;


public class TestSort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] x = {7,10,1,4,5,7,8,6,11,2};
		//popSort(x,0,8);
		//selectSort(x, 0, 8);
		//insertSort(x, 0, 8);
		//shellSort(x);
		
		//mergeSort(x, 0, 8);
		//quickSort(x, 0, 9);
		heapSort(x);
		for(int i = 0 ; i < x.length;i++)
		{
			System.out.println(x[i]);
		}

	}

	/**
	 * 冒泡排序算法,相邻元素的交换，循环进行
	 * @param array
	 * @param start
	 * @param end
	 */
	public static void popSort(int[] array, int start,int end)
	{
		for(int i = start; i < end; i++)
			for(int j = start+1; j < end-i; j ++)
			{
				if(array[j-1] > array[j])
				{
					swap(array,j-1,j);
				}
			}
	}
	
	private static void swap( int[] array, int first,int second)
	{
		int temp = array[first];
		array[first] = array[second];
		array[second] = temp;
	}
	
	/**
	 * 选择排序，从头开始，挑选出最小的元素的下表，和数组的头元素替换，循环进行
	 * @param array
	 * @param start
	 * @param end
	 */
	public static void selectSort(int[] array, int start,int end)
	{
		int mini = start;
		for(int i= start+1; i < end; i++)
		{
			for(int j = i ; j < end; j++)
			{
				if(array[j] < array[mini])
				{
					mini = j;
				}
			}
			swap(array,mini,i-1);
			mini = i;
		}
	}
	
	/**
	 * 插入排序，在数据头建立一个局部有序的子序列，然后依次把无序的数字插入到该子序列中，形成最终的完成排序
	 * @param array
	 * @param start
	 * @param end
	 */
	public static void insertSort(int[] array,int start,int end)
	{
		for(int i = start+1; i < end; i++)
		{
			int temp = array[i];
			int j = i;
			while( j >0 && array[j-1] > temp)
			{
				array[j] = array[j-1];
				j--;
			}
			array[j] = temp;
		}
	}
	
	/**
	 * shell排序
	 * 
	 * @param array
	 */
	public static void shellSort(int[]  array)
	{
		//先设定步长为一半，然后慢慢减小。最后到达1
		for(int step = array.length/2 ; step > 0 ; step = step/2)
			//执行制定步长的插入排序
			for(int j = step; j < array.length; j++)
			{
				int temp = array[j];
				int k = j;
				while (k > 0 && array[k-step] > temp)
				{
					array[k] = array[k-step];
					k = k-step;
				}
				array[k] = temp;
			}
	}
	
	/**
	 * 归并排序
	 * @param array
	 * @param left
	 * @param right
	 */
	public static void mergeSort(int[] array,int left,int right)
	{
		if(left >= right)
			return;
		int center = (left + right)/2;
		//递归
		mergeSort(array,left,center);
		mergeSort(array,center+1,right);
		//合并
		merge(array,left,center,right);
	}
	
	private static void merge(int[] array,int left,int center,int right)
	{
		int[] tempArr = new int[array.length];
		int index = left;
		int mid = center+1;
		int temp = left;
		
		while(left <= center && mid <= right)
		{
            // 从两个数组中取出最小的放入临时数组
			if(array[left] <= array[mid])
			{
				tempArr[index++] = array[left++];
			}
			else
			{
				tempArr[index++] = array[mid++];
			}
		}
        // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
		while(mid <= right)
		{
			tempArr[index++] = array[mid++];
		}
		while(left <= center)
		{
			tempArr[index++] = array[left++];
		}
        // 将临时数组中的内容拷贝回原数组中
		while(temp <= right)
		{
			array[temp] = tempArr[temp++];
		}
	}
	
	/**
	 * 快速排序
	 * @param array
	 * @param left
	 * @param right
	 */
	public static void quickSort(int[] array,int left,int right)
	{
		if(left >= right)
			return;
		int index = getmid(array,left,right);
		quickSort(array, left, index-1);
		quickSort(array, index+1, right);
		
	}
	
	private static int getmid(int[] array,int left,int right)
	{
		//选取key
		int key = array[left];
		while(left < right)
		{
            //从后向前搜索比key小的值
			while(array[right] >= key && right > left)
				right--;
            //比key小的放左边
			array[left] = array[right];
            //从前向后搜索比key大的值，比key大的放右边
			while(array[left] <= key && right > left)
				left++;
            //比key大的放右边
			array[right] = array[left];
		}
        //左边都比key小，右边都比key大。将key放在游标当前位置。此时low等于high
		array[right] = key;
		//System.out.println(Arrays.toString(array));
		return right;
	}
	
	/**
	 * 堆排序
	 * @param array
	 */
	public static void heapSort(int[] array){
        buildHeap(array);//构建堆
        int n = array.length;
        int i=0;
        for(i=n-1;i>=1;i--)
        {
            //先将堆首元素和数组的最后一个元素交换，然后对之前的堆进行堆调整
        	swap(array,0,i);
            heapify(array,0,i);
        }
    }
    
    public static void buildHeap(int[] array){
        int n = array.length;//数组中元素的个数
        for(int i=n/2-1;i>=0;i--)
        	//递归建堆
            heapify(array,i,n);
            
    }
    public static void heapify(int[] A,int idx,int max){
        int left = 2*idx+1;// 左孩子的下标（如果存在的话）
        int right =2*idx+2;// 左孩子的下标（如果存在的话）
        int largest = 0;//寻找3个节点中最大值节点的下标
        if(left<max && A[left]>A[idx])
            largest = left;
        else
            largest = idx;
        if(right<max && A[right]>A[largest])
            largest = right;
        if(largest!=idx)
        {
            swap(A,largest,idx);
            heapify(A,largest,max);            
        }    
    }
	
	
}