六种常见排序算法的java实现

package edu.cn.ysw;

//八种排序算法的实现与效率分析
/*
 * 内排序的种类：
 * 1.插入排序：直接插入排序、希尔排序。
 * 2.选择排序：简单选择排序、堆排序。
 3.交换排序：冒泡排序、快速排序。
 4.归并排序
 5.基数排序
 */
public class SortedMethods {

	/**
	 * @author ysw
	 * @param args
	 * @throws Exception
	 * @since 6/15/2017
	 */
	// 直接插入排序:1.有哨兵;2.无哨兵
	// 无哨兵
	public void insertSortWithoutPre(int arr[]) {
		if (arr == null || arr.length == 0) {
			return;
		}
		// 外层循环定义排序次数
		for (int i = 1; i < arr.length; i++) {
			// 不满足条件则忽略此次判断，相当于continue;
			if (arr[i] < arr[i - 1]) {
				int tempValue = arr[i];
				int j;
				for (j = i - 1; j >= 0 && tempValue < arr[j]; j--) {
					arr[j + 1] = arr[j];
				}
				arr[j + 1] = tempValue;
			}
		}
	}

	// 有哨兵的直接插入排序
	public void insertSortWithPre(int arr[]) {
		for (int i = 2; i < arr.length; i++) {
			/*
			 * 哨兵的作用： 1:保存等待插入的数字; 2:防止数组越界的情况;
			 */
			if (arr[i] < arr[i - 1]) {
				arr[0] = arr[i];
				int j;
				for (j = i - 1; arr[0] < arr[j]; j--) {
					arr[j + 1] = arr[j];
				}
				arr[j + 1] = arr[0];
			}
		}
	}

	// 希尔排序
	public void shellSort(int arr[]) {
		if (arr == null || arr.length == 0) {
			return;
		}
		// 增量序列
		int incrementValue = arr.length / 2;
		while (incrementValue >= 1) {
			for (int i = 0; i < arr.length; i++) {
				for (int j = i + incrementValue; j < arr.length; j += incrementValue) {
					int temp = arr[j];
					int k;
					for (k = j - incrementValue; k >= 0 && arr[k] > temp; k = k
							- incrementValue) {
						arr[k + incrementValue] = arr[k];
					}
					arr[k + incrementValue] = temp;
				}
			}
			// 改变递增序列的值
			incrementValue /= 2;
		}
	}

	/*
	 * 选择排序： 1.简单选择排序 2.堆排序
	 */

	// 简单选择排序
	public void selectSort(int arr[]) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[i] > arr[j]) {
					swap(arr, i, j);
				}
			}
		}
	}

	// 堆排序：实践中多用于调度算法，比如线程优先级调度
	// 时间驱动：取最小值或者等待时间最长

	// 冒泡排序
	public void bubbleSort(int arr[]) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					swap(arr, j, j + 1);
				}
			}
		}
	}

	// 快速排序：挖坑填数+分治

	// 快速排序返回基准值最终位置的函数partition:回调整后基准数的位置
	public int partition(int arr[], int l, int r) {
		// 假设第一个基准值为arr[0];
		int left = l;
		int right = r;
		int key = arr[left];
		while (left < right) {
			while (left < right && arr[right] >= key) {
				right--;
			}
			if (left < right) {
				arr[left] = arr[right];
				left++;
			}
			while (left < right && arr[left] <= key) {
				left++;
			}
			if (left < right) {
				arr[right] = arr[left];
				right--;
			}
		}
		arr[left] = key;

		return left;
	}

	// 快速排序
	public void quickSort(int arr[], int l, int r) {
		if (l < r) {
			int index = partition(arr, l, r);
			quickSort(arr, l, index - 1);
			quickSort(arr, index + 1, r);
		}
	}

	// 归并排序

	public void mergeSort(int arr[]) {
		sort(arr, 0, arr.length - 1);
	}

	public void sort(int[] arr, int left, int right) {
		if (left >= right) {
			return;
		}
		int center = (left + right) / 2;
		sort(arr, left, center);
		sort(arr, center + 1, right);
		merge(arr, left, center, right);
	}

	public void merge(int[] arr, int left, int center, int right) {
		// 定义一个辅助数组来存放归并的两个子数组
		int tempArray[] = new int[arr.length];
		// 左面子数组的第一个元素
		int leftFirst = left;
		// 右面子数组的第一个元素
		int rightFirst = center + 1;
		// 指向辅助数组的第一个元素
		int tempPointer = left;
		while (leftFirst <= center && rightFirst <= right) {
			if (arr[leftFirst] <= arr[rightFirst]) {
				tempArray[tempPointer++] = arr[leftFirst++];
			} else {
				tempArray[tempPointer++] = arr[rightFirst++];

			}
		}

		// 将第一个数组中剩下的元素添加到辅助数组中
		while (leftFirst <= center) {
			tempArray[tempPointer++] = arr[leftFirst++];
		}
		// 将第二个数组中剩下的元素添加到辅助数组中
		while (rightFirst <= right) {
			tempArray[tempPointer++] = arr[rightFirst++];
		}
	}

	// 打印数组的函数
	public void printArr(int arr[]) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]);
			if (i != arr.length - 1) {
				System.out.print(",");
			}
		}
		System.out.println();
	}

	// 交换数组的元素
	public void swap(int arr[], int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	public static void main(String[] args) {
		SortedMethods sMethods = new SortedMethods();
		// 测试需要的数组
		int array1[] = { 1, 2, 3, 4, 5 };
		int array2[] = { 5, 4, 3, 2, 1 };
		int array3[] = { 4, 5, 2, 1, 7 };
		int array4[] = null;
		int array5[] = new int[0];
		// 测试无哨兵的插入排序

		System.out.println("--------有哨兵插入排序--------------");

		sMethods.insertSortWithoutPre(array1);
		sMethods.printArr(array1);
		sMethods.insertSortWithoutPre(array2);
		sMethods.printArr(array2);
		sMethods.insertSortWithoutPre(array3);
		sMethods.printArr(array3);
		/*
		 * sMethods.insertSortWithoutPre(array4); sMethods.printArr(array4);
		 * sMethods.insertSortWithoutPre(array5); sMethods.printArr(array5);
		 */
		System.out.println("--------无哨兵插入排序------------");
		// 测试有哨兵的插入排序
		sMethods.insertSortWithoutPre(array1);
		sMethods.printArr(array1);
		sMethods.insertSortWithoutPre(array2);
		sMethods.printArr(array2);
		sMethods.insertSortWithoutPre(array3);
		sMethods.printArr(array3);
		System.out.println("----------希尔排序------------");
		// 测试希尔排序
		sMethods.shellSort(array1);
		sMethods.printArr(array1);
		sMethods.shellSort(array2);
		sMethods.printArr(array2);
		sMethods.shellSort(array3);
		sMethods.printArr(array3);
		System.out.println("---------简单选择排序------------");
		sMethods.selectSort(array1);
		sMethods.printArr(array1);
		sMethods.selectSort(array2);
		sMethods.printArr(array2);
		sMethods.selectSort(array3);
		sMethods.printArr(array3);
		System.out.println("---------冒泡排序------------");
		sMethods.bubbleSort(array1);
		sMethods.printArr(array1);
		sMethods.bubbleSort(array2);
		sMethods.printArr(array2);
		sMethods.bubbleSort(array3);
		sMethods.printArr(array3);
		System.out.println("---------快速排序------------");
		sMethods.quickSort(array3, 0, array3.length - 1);
		sMethods.printArr(array3);
		System.out.println("---------归并排序排序------------");
		sMethods.mergeSort(array3);
		sMethods.printArr(array3);

	}

}