java排序

package com.yang.utils;

public class Sorter {
	// -------------------------------------------------------------------
	public static final int ASCENT = 1;
	public static final int DECENT = 2;

	public static final int BUBBLESORT = 1;
	public static final int QUICKSORT = 2;
	public static final int INSERTSORT = 3;
	public static final int CHOOSESORT = 4;
	public static final int MERGSORT = 5;
	public static final int SHELLSORT = 6;

	// ///
	public static void sort(int[] data, int flag) {
		switch (flag) {
		case BUBBLESORT:
			bubbleSort(data);
			break;
		case INSERTSORT:
			insertSort(data);
			break;
		case CHOOSESORT:
			chooseSort(data);
			break;
		case QUICKSORT:
			quickSort(data, 0, data.length - 1);
			break;
		case MERGSORT:
			mergSort(data);
			break;
		case SHELLSORT:
			shellSort(data);
			break;
		default:
			break;

		}
	}

	// ---------------------------------------------------------------------

	// -------------------------冒泡排序(stable)----------------------------------
	public synchronized static void bubbleSort(int[] in) {
		int len = in.length;
		for (int i = 0; i < len - 1; i++) {
			for (int j = i + 1; j < len; j++) {
				if (in[i] > in[j]) {
					int buff = in[i];
					in[i] = in[j];
					in[j] = buff;
				}
			}
		}
	}

	// -------------------------插入排序(stable)----------------------------------
	public synchronized static void insertSort(int[] in) {
		int len = in.length;
		for (int i = 1; i < len; i++) {
			for (int j = i; j > 0; j--) {
				if (in[j] < in[j - 1]) {
					int buff = in[j];
					in[j] = in[j - 1];
					in[j - 1] = buff;
				} else
					break;
			}
		}
	}

	// -------------------------选择排序----------------------------------
	public synchronized static void chooseSort(int[] in) {
		int len = in.length;
		for (int i = 0; i < len - 1; i++) {
			int index = i;
			for (int j = i + 1; j < len; j++) {
				if (in[j] < in[index]) {
					index = j;
				}
			}
			if (index != i) {
				int buff = in[i];
				in[i] = in[index];
				in[index] = buff;
			}
		}
	}

	// -------------------------快速排序----------------------------------
	public synchronized static void quickSort(int[] in, int f, int l) {
		int m = in[f], i = f, j = l;
		while (i < j) {
			while (i < j && m < in[j])
				j--;// 找到第一个小于m的索引
			if (i < j) {
				in[i] = in[j];
				i++;
			}
			while (i < j && m > in[i])
				i++;
			if (i < j) {
				in[j] = in[i];
				j--;
			}
			in[i] = m;
		}
		if (i > f)
			quickSort(in, f, i);
		if (j < l)
			quickSort(in, i + 1, l);
	}

	// -------------------------归并排序(stable)----------------------------------
	public synchronized static void mergSort(int[] in) {
		int[] temp = new int[in.length];
		doMergSort(in, temp, 0, in.length - 1);
	}

	private synchronized static void doMergSort(int[] data, int[] temp,
			int lowerBound, int uperBound) {
		if (lowerBound == uperBound)
			return;
		else {
			int mid = (lowerBound + uperBound) / 2;
			doMergSort(data, temp, lowerBound, mid);// 排序前一半
			doMergSort(data, temp, mid + 1, uperBound);// 排序后一半
			merg(data, lowerBound, mid + 1, uperBound, temp);// 二者合并
		}

	}

	private synchronized static void merg(int[] data, int s, int m, int t,
			int[] temp) {
		int i = s, j = m, k = 0, n = t - s + 1;
		while (i < m && j <= t) {
			if (data[i] < data[j])
				temp[k++] = data[i++];
			else
				temp[k++] = data[j++];
		}
		while (i < m)
			temp[k++] = data[i++];
		while (j <= t)
			temp[k++] = data[j++];
		System.arraycopy(temp, 0, data, s, n);

	}

	// -------------------------希尔排序----------------------------------
	public synchronized static void shellSort(int[] data) {
		int h = 1;
		while (h < data.length / 3)
			h = h * 3 + 1;// 最大间隔
		System.out.println("shellsort max interval:" + h);
		while (h > 0) {
			for (int i = h; i < data.length; i++) {
				int temp = data[i];
				int j = i;
				while (j > h - 1 && data[j - h] > temp) {
					data[j] = data[j - h];
					j -= h;
				}
				data[j] = temp;
			}
			h = (h - 1) / 3;
		}
	}
	//

}