Java高级排序（希尔排序，快速排序，堆排序，归并排序，桶排序）

/**
 * 希尔排序
 * @author shuang
 *
 */
public class ShellSort {
	public static void shellSort(int[] array) {
		int step=array.length;//增量
		while(step!=1) {
			step/=2;
            for (int i=0;i<step;i++) {
            	for (int j=i+step;j<array.length;j+=step) {
            		for (int k=i;k<j;k+=step) {
            			if (array[k]>array[j]) {
            				int temp=array[j];
            				for (int h=j;h>k;h-=step) {
            					array[h]=array[h-step];
            				}
            				array[k]=temp;
            			}
            		}
            	}
            }
		}
	}
	public static void print(int[] array) {
		for (int i=0;i<array.length;i++) {
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int[] array = {3,1,5,8,6,12,56,2,64,90,51};
		print(array);
		System.out.println("----------排序后---------");
	    shellSort(array);
		print(array);
	}
}

/**
 * 快速排序
 * @author shuang
 *
 */
public class QuickSort {
	public static void quickSort(int[] array,int left,int right) {
		if (left < right) {
			int middle = partition(array,left,right);
			//对左右的数据进行排序
			quickSort(array,left,middle-1);
			//对右边的数据进行排序
			quickSort(array,middle+1,right);
		}
	}
	/**
	 * 分区
	 * @param array
	 * @param left
	 * @param right
	 * @return 返回零界点位置坐标
	 */
	private static int partition(int[] array,int left,int right) {
		int key=array[left];//关键字
		while(left < right) {//left==right的时候终止循环
			while(left < right && array[right] > key) {
				right--;//向左移动
			}
			//让右端的数字移到左端
			array[left] = array[right];
			
			while(left < right && array[left] < key) {
				left++;//向右移动
			}
			//让左端的数字移到右端
			array[right] = array[left];
		}
	    array[left]=key;
	    return left;
	}
	public static void print(int[] array) {
		for (int i=0;i<array.length;i++) {
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int[] array = {3,1,5,8,6,12,56,2,64,90,51};
		print(array);
		System.out.println("----------排序后---------");
	    quickSort(array,0,array.length-1);
		print(array);
	}
	
}

/**
 * 堆排序
 * @author shuang
 *
 */
public class HeapSort {
	public static void heapSort(int[] array) {
		buildMaxHeap(array);
		for (int i=array.length-1;i > 0;i--) {//堆有效数递减
			int temp = array[0];
			array[0] = array[i];
			array[i] = temp;
			maxHeap(array,i,0);
		}
	}
	/*
	 * 构建最大堆
	 */
	private static void buildMaxHeap(int[] array) {
		for (int i = (array.length-1) / 2; i >= 0; i--) {
			maxHeap(array,array.length,i);
		}
	}
	/*
	 * 调整堆
	 */
	private static void maxHeap(int[] array,int size,int index) {
		int left = index * 2 + 1;
		int right = index * 2 + 2;
		int max = index;
		if (left < size && array[left] > array[index]) {
			max = left;
		}
		if (right < size && array[right] > array[max]) {
			max = right;
		}
		if (max != index) {
			int temp = array[index];
			array[index] = array[max];
			array[max] = temp;
			maxHeap(array,size,max);
		}
	}
	public static void print(int[] array) {
		for (int i=0;i<array.length;i++) {
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int[] array = {3,1,5,8,6,12,56,2,64,90,51}; 
		print(array);
		System.out.println("----------排序后---------");
	    heapSort(array);
		print(array);
	}
	
}

/**
 * 归并排序
 * @author shuang
 *
 */
public class MergeSort {
	public static void merge(int[] array,int first,int middle,int last,int[] temp) {
		int i = first;//最左边左边的下标
		int j = middle + 1;//最右边的左边下标
		int k = 0;//临时数据索引
		while(i <= middle && j <= last) {
			if (array[i] < array[j]) {
				temp[k++] = array[i++];
			}else {
				temp[k++] = array[j++];
			}
		}
		while(i <= middle) {
			temp[k++] = array[i++];
		}
		while(j <= last) {
			temp[k++] = array[j++];
		}
		for (int n = 0; n< k; n++) {
			array[first + n] = temp[n];
		}
	}
	/*
	 * 先拆分后后合并
	 */
	public static void mergeSort(int[] array,int first,int last,int[] temp) {
		if (first < last) {
			int middle = (first + last) / 2;
			mergeSort(array,first,middle,temp);//左边有序
			mergeSort(array,middle+1,last,temp);//右边有序性
			merge(array,first,middle,last,temp);//合并数据
		}
	}
	public static void print(int[] array) {
		for (int i=0;i<array.length;i++) {
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int[] array = {3,1,5,8,6,12,56,2,64,90,51};
		print(array);
		System.out.println("----------排序后---------");
		int[] temp = new int[array.length];
	    mergeSort(array,0,array.length-1,temp);
		print(array);
	}
}

import java.util.LinkedList;
import java.util.Queue;

/**
 * 桶排序
 * @author shuang
 *
 */
public class BucketSort {
	/**
	 * 桶排序
	 * @param array 数据
	 * @param m 最大位数
	 * @param d 桶的个数
	 */
	public static void bucketSort(int[] array, int m, int d) {
		Queue<Integer>[] bucket = new LinkedList[d];
		int p = 1;
		int k = 0;
		//初始化桶数量
		for (int i = 0; i < d; i++) {
			bucket[i] = new LinkedList<Integer>();
		}
		for (int j = 0; j < m; j++) {
			if (j ==0) {
				p = 1;
			} else {
				p *=d;
			}
			//把数据放入到指定的桶中
			for (int n = 0; n < array.length; n++) {
				k = array[n] / p-(array[n] / (p * d))*d;
				bucket[k].add(array[n]);
			}
			//把桶中的数据取出来放入数据组中
			int l = 0;
			for (int h = 0; h < d; h++) {
				while(!bucket[h].isEmpty()) {
					array[l] = bucket[h].remove().intValue();
					l++;
				}
			}
		}
	}
	public static void print(int[] array) {
		for (int i=0;i<array.length;i++) {
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int[] array = {31,122,511,84,6,12,56,22,64,90,51};
		print(array);
		System.out.println("----------排序后---------");
	    bucketSort(array,3,10);
		print(array);
	}
}