一些经典排序算法的java实现

1.插入排序

/**
	 * 利用插入排序给数组排序的算法,没有返回值,当执行完方法后,输入数组就a就已经包含了已经排好序的输出序列
	 * 
	 * @param a
	 *            接收一个 int 型的数组
	 */
	public static void insertionSort(int[] a) {
		int key, i;
		for (int j = 1; j < a.length; j++) {
			key = a[j];
			i = j - 1;
			while (i >= 0 && a[i] > key) {
				a[i + 1] = a[i];
				i = i - 1;
			}
			a[i + 1] = key;
		}
	}

2.合并排序

/**
	 * 对int型数组进行排序的方法,利用合并排序算法,利用分治法的思想,不断合并递归
	 * 
	 * @param arr
	 *            接收一个int型的数组
	 * @param p
	 *            需要排序的起始元素
	 * @param r
	 *            待排序的 终止元素
	 */
	public static void mergeSort(int[] arr, int p, int r) {
		int q;
		if (p < r) {
			q = (p + r) / 2;
			mergeSort(arr, p, q);
			mergeSort(arr, q + 1, r);
			merge(arr, p, q, r);
		}
	}

	// 分治法排序
	private static void merge(int[] arr, int p, int q, int r) {
		int n1 = q - p + 1;
		int n2 = r - q;
		int[] L = new int[n1 + 1];
		int[] R = new int[n2 + 1];
		for (int i = 0; i < n1; i++) {
			L[i] = arr[p + i];
		}
		for (int j = 0; j < n2; j++) {
			R[j] = arr[q + j + 1];
		}
		L[n1] = Integer.MAX_VALUE;
		R[n2] = Integer.MAX_VALUE;
		int i = 0;
		int j = 0;
		for (int k = p; k < r + 1; k++) {
			if (L[i] <= R[j]) {
				arr[k] = L[i];
				i++;
			} else {
				arr[k] = R[j];
				j++;
			}
		}
	}

3.冒泡排序

/**
	 * 冒泡排序,对一个整型数组进行排序
	 * 
	 * @param arr
	 *            接收一个整型数组
	 */
	public static void bubbleSort(int[] arr) {
		for(int i=0;i<arr.length;i++){
			for(int j=arr.length-1;j>i;j--){
				if(arr[j]<arr[j-1])
				{
					int temp;
					temp = arr[j-1];
					arr[j-1]=arr[j];
					arr[j]=temp;
				}
			}
		}
	}

4.堆排序

/**
	 * 堆排序:对一个整型数组进行排序 堆排序的运行时间为O(nlgn).它是一种原地(in place)排序算法,在任何时候只有常数个元素存储在数组之外
	 * 堆排序引入 堆数据结构  管理算法执行中的信息 
	 * 	  堆数据结构不只是在堆排序中有用,还可以构成一个有效的优先队列.
	 * @param arr 接收一个整型数组
	 * 
	 */
	private static int heap_size;
	public static void heapSort(int[] arr){
		
		build_MAX_heap(arr);
		for (int i = arr.length; i>=2; i--) {
			int temp = arr[0];
			arr[0] = arr[i-1];
			arr[i-1] = temp;
			heap_size = heap_size -1;
			MAX_heapify(arr, 1);
		}
	}

	private static void build_MAX_heap(int[] arr) {
		heap_size = arr.length;
		for (int i = arr.length/2; i>=1; i--) {
			MAX_heapify(arr,i);
		}
	}

	private static void MAX_heapify(int[] arr, int i) {
		int largest;
		int l = 2*i;    //lift(i)
		int r = 2*i +1; //right(i)
		if(l<=heap_size && arr[l-1]>arr[i-1]){
			largest = l;
		}
		else{
			largest = i;
		}
		if(r<=heap_size && arr[r-1]>arr[largest-1]){
			largest = r;
		}
		if(largest!=i){
			int temp = arr[i-1];
			arr[i-1] = arr[largest-1];
			arr[largest-1] = temp;
			MAX_heapify(arr, largest);
		}	
	}