java的几种常用排序方法集合

JAVA实现部分排序方法


public class SortTest {
	public static void main(String[] args) {
		int[] a = { 3, 5, 2, 1, 9, 10, 8, 7, 6, 1, 2, 4 }; 	
		System.out.print("数组原序：           ");	
		for (int k = 0; k < a.length; k++) {
			System.out.print(a[k] + " ");
		}
		System.out.println();
		
		// swap(int[]a ,int i,int j);交换方法
		int p=0;//0代表数组索引的第一个数字
		int q=2;//位置的交换
		swap(a,p,q);
		System.out.print("交换方法：           ");
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println();		
		
		// bubbleSort(a);冒泡排序
		bubbleSort(a);
		System.out.print("冒泡排序：           ");
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println();
		
		//selectSort(a);直接选择排序
		selectSort(a);
		System.out.print("直接选择排序： ");
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println();
		
		// insertSort(a);插入排序方法
		insertSort(a);
		System.out.print("插入排序方法： ");
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println();
		
		// reverse(a);反转数组方法
		reverse(a);
		System.out.print("反转数组方法： ");
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println();

		// quitSort(int[] a, int low, int hight)快速排序法
		int low = 0;
		int hight=11;
		quitSort(a,low,hight);
		System.out.print("快速排序方法： ");
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println();
		
	}

	/** * 交换方法 * @param a * @param i * @param j */
	public static void swap(int[] a, int i, int j) {
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}

	/** * 冒泡排序 * @param a */
	public static void bubbleSort(int[] a) {
		for (int i = 0; i < a.length; i++) {
			for (int j = i; j < a.length; j++) {
				if (a[i] > a[j]) {
					swap(a, i, j);
				}
			}
		}
	}

	/**
	 * * 直接选择排序法----选择排序的一种 方法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素， *
	 * 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 性能：比较次数O(n^2),n^2/2 交换次数O(n),n *
	 * 交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。 *
	 * 但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些。 * 
	 * * @param data *
	 * 要排序的数组 * @param sortType * 排序类型 * @return
	 */
	public static void selectSort(int[] data) {
		int index;
		for (int i = 0; i < data.length; i++) {
			index = i;
			for (int j = i + 1; j < data.length; j++) {
				if (data[index] > data[j]) {
					index = j;
				}
			} // 交换在位置i和index(最大值)两个数
			swap(data, i, index);
		}
	}

	/**
	 * 插入排序方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。
	 * 性能：比较次数O(n^2),n^2/4 * 复制次数O(n),n^2/4 比较次数是前两者的一般，而复制所需的CPU时间较交换少，
	 * 所以性能上比冒泡排序提高一倍多，而比选择排序也要快。 * 
	 *  @param data     要排序的数组
	 *  @param sortType 排序类型
	 */
	public static void insertSort(int[] data) { // 比较的轮数
		for (int i = 1; i < data.length; i++) {
			// 保证前i+1个数排好序
			for (int j = 0; j < i; j++) {
				if (data[j] > data[i]) {
					// 交换在位置j和i两个数
					swap(data, i, j);
				}
			}
		}
	}

	/**
	 * * 反转数组的方法 * *
	 *  @param data * 源数组
	 */
	public static void reverse(int[] data) {
		int length = data.length;
		int temp = 0;
		// 临时变量
		for (int i = 0; i < length / 2; i++) {
			temp = data[i];
			data[i] = data[length - 1 - i];
			data[length - 1 - i] = temp;
		}
	}

	/**
	 * * 快速排序 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。
	 * 步骤为： 
	 *  1. 从数列中挑出一个元素，称为 "基准"（pivot）， 
	 *  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面 （相同的数可以到任一边）。
	 *  	在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。
	 *  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
	 *  	递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。
	 * 		虽然一直递回下去，但是这个算法总会结束，因为在每次的迭代（iteration）中， 
	 * 		它至少会把一个元素摆到它最后的位置去。
	 */
	public static void quitSort(int[] a, int low, int hight)// 快速排序法
	{
		int i, j, k = 0;
		if (low < hight)// 先保存
		{
			i = low;
			j = hight;
			k = a[i];
			while (i < j) {
				while (i < j && a[j] > k) {
					j--;
				}
				if (i < j) {// 从后往前排序
					a[i] = a[j];
					i++;
				}
				while (i < j && a[i] < k) {
					i++;
				}
				if (i < j) {// 从前往后排序
					a[j] = a[i];
					j--;
				}
			}
			a[i] = k;
			quitSort(a, low, i - 1);
			quitSort(a, i + 1, hight);
		}
	}

}