排序算法

package a.b.c.mytest;

import java.util.Arrays;

public class TestSort {

	/**
	 * 插入排序
	 * 
	 * @param arr
	 */
	public static void insertionSort(int arr[]) {
		int size = arr.length;
		for (int i = 1; i < size; i++) {
			for (int j = 0; j < i; j++) {
				if (arr[i] < arr[j]) {
					int tmp = arr[j];
					arr[j] = arr[i];
					arr[i] = tmp;
				}
			}
		}
	}

	/**
	 * 冒泡排序
	 * 
	 * @param arr
	 */
	public static void maopaoSort(int arr[]) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					int tmp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = tmp;
				}
			}
		}
	}

	/**
	 * 分治法,归并排序
	 * 
	 * @param arr
	 */
	public static void mergeSort(int arr[], int start, int end) {
		if (start + 1 < end) {
			int middle = (start + end) / 2;
			mergeSort(arr, start, middle);
			mergeSort(arr, middle, end);
			// merge
			int left[] = Arrays.copyOfRange(arr, start, middle);
			int right[] = Arrays.copyOfRange(arr, middle, end);
			int leftSize = left.length, leftPtr = 0;
			int rightSize = right.length, rightPtr = 0;
			for (int i = start; i < end; i++) {
				if (leftPtr >= leftSize) {
					arr[i] = right[rightPtr];
					rightPtr++;
				} else if (rightPtr >= rightSize) {
					arr[i] = left[leftPtr];
					leftPtr++;
				} else {
					if (left[leftPtr] <= right[rightPtr]) {
						arr[i] = left[leftPtr];
						leftPtr++;
					} else {
						arr[i] = right[rightPtr];
						rightPtr++;
					}
				}
			}
		}
	}

	/**
	 * 堆排序
	 * 
	 * @param arr
	 */
	public static void heapSort(int arr[]) {
		buildHeap(arr);
		for (int i = arr.length; i > 1; i--) {
			int tmp = arr[0];
			arr[0] = arr[i - 1];
			arr[i - 1] = tmp;
			maxHeapify(arr, 0, i - 1);
		}
	}

	// 保持最大堆性质
	private static void maxHeapify(int arr[], int i, int heapSize) {
		int left = 2 * i + 1;
		int right = 2 * i + 2;
		int max = i;
		if (left + 1 <= heapSize && arr[left] > arr[i]) {
			max = left;
		}

		if (right + 1 <= heapSize && arr[right] > arr[max]) {
			max = right;
		}

		if (max != i) {
			int tmp = arr[i];
			arr[i] = arr[max];
			arr[max] = tmp;
			maxHeapify(arr, max, heapSize);
		}
	}

	// 构建最大堆
	private static void buildHeap(int arr[]) {
		for (int i = arr.length / 2 - 1; i >= 0; i--) {
			maxHeapify(arr, i, arr.length);
		}
	}

	/**
	 * 快速排序
	 * @param arr
	 * @param start
	 * @param end
	 */
	public static void quickSort(int arr[], int start, int end) {
		if(start < end){
			    int middle = arr[start];
			    int left = start;
			    int right = end;
			    while(left < right){
			    	while(left < right && arr[right] >= middle){
			    		right --;
			    	}
			    	arr[left] = arr[right];
			    	
			    	while(left<right && arr[left] < middle){
			    		left ++;
			    	}
			    	arr[right] = arr[left];
			    }
			    arr[left] = middle;
			    quickSort(arr,start,left-1);
			    quickSort(arr,left+1,end);
		}  
	}
	
	/**
	 * 计数排序
	 * @param arr
	 * @param max
	 */
	public static void countingSort(int arr[],int max){
		int c[] = new int[max+1];
		for(int i=0;i<=max;i++){
			c[i] = 0;
		}
		
		for(int i=0;i<arr.length;i++){
			c[arr[i]] = c[arr[i]] + 1;
		}
		
		for(int i=1;i<=max;i++){
			c[i] = c[i-1] + c[i];
		}
		
		int b[] = new int[arr.length];
		
		for(int i=b.length-1;i>=0;i--){
			b[c[arr[i]] - 1] = arr[i];
			c[arr[i]] = c[arr[i]] - 1;
		}
		
		for(int i=0;i<b.length;i++){
			arr[i] = b[i];
		}
	}
	
	
	

	public static void main(String args[]) {
		int arr[] = { 5, 3, 4, 1, 2 };
		System.out.println("原数组：" + Arrays.toString(arr));
		TestSort.insertionSort(arr);
		System.out.println("插入排序结果：" + Arrays.toString(arr));

		int arr1[] = { 5, 3, 4, 1, 2, 10, 4, 9, 7, 8 };
		System.out.println("原数组：" + Arrays.toString(arr1));
		TestSort.mergeSort(arr1, 0, arr1.length);
		System.out.println("归并排序结果：" + Arrays.toString(arr1));

		int arr2[] = { 50, 3, 4, 1, 2, 10, 4, 9, 7, 8 };
		System.out.println("原数组：" + Arrays.toString(arr2));
		TestSort.maopaoSort(arr2);
		System.out.println("冒泡排序结果：" + Arrays.toString(arr2));

		int arr3[] = { 50, 300, 4, 1, 2, 10, 42, 98, 7, 8 };
		System.out.println("原数组：" + Arrays.toString(arr3));
		TestSort.heapSort(arr3);
		System.out.println("堆排序结果：" + Arrays.toString(arr3));
		
		
		int arr4[] = { 50, 300, 4, 1, 2, 10, 42, 98, 7, 8 };
		System.out.println("原数组：" + Arrays.toString(arr4));
		TestSort.quickSort(arr4, 0, arr4.length -1);;
		System.out.println("快速排序结果：" + Arrays.toString(arr4));
		

		int arr5[] = { 500, 300, 4, 1, 2, 10, 42, 98, 7, 8 };
		System.out.println("原数组：" + Arrays.toString(arr5));
		TestSort.countingSort(arr5, 500);
		System.out.println("计数排序结果：" + Arrays.toString(arr5));
	}

}