常用排序算法-JAVA实现

直接上代码。

import java.util.Arrays;

public class Sort {

	public static void main(String[] args) {

		int[] sample = new int[] { 8, 9, 7, 10, 6, 2, 4, 5, 1, 0, 3 };
		insertionSort(sample);

		sample = new int[] { 8, 9, 7, 10, 6, 2, 4, 5, 1, 0, 3 };
		bInsertionSort(sample);

		sample = new int[] { 8, 9, 7, 10, 6, 2, 4, 5, 1, 0, 3 };
		cocktailSort(sample);

		sample = new int[] { 8, 9, 7, 10, 6, 2, 4, 5, 1, 0, 3 };
		shellSort(sample);

		sample = new int[] { 8, 9, 7, 10, 6, 2, 4, 5, 1, 0, 3 };
		selectionSort(sample);

		sample = new int[] { 8, 9, 7, 10, 6, 2, 4, 5, 1, 0, 3 };
		bubbleSort(sample);

		sample = new int[] { 8, 9, 7, 10, 6, 2, 4, 5, 1, 0, 3 };
		quickSort(sample, 0, sample.length - 1);
		System.out.println("快速排序 " + Arrays.toString(sample));

		sample = new int[] { 8, 9, 7, 10, 6, 2, 4, 5, 1, 0, 3 };
		mergeSort(sample, 0, sample.length - 1);
		System.out.println("归并排序 " + Arrays.toString(sample));

	}

	// 直接插入排序（见缝插针排序），最好n-1,最差n(n-1)/2，复杂度n方
	// 直接插入排序的稳定性取决于换位置条件对等号的处理，不带等号稳定
	public static void insertionSort(int[] data) {

		int d;
		for (int i = 1; i < data.length; i++) {
			d = data[i];
			for (int j = i; j > 0; j--) {
				if (data[j - 1] > d) {
					data[j] = data[j - 1];
					data[j - 1] = d;
				}
			}
		}
		System.out.println("直接插入排序 " + Arrays.toString(data));

	}

	// 二分插入排序，最好nlog(n),最差n方，复杂度n方
	// 二分插入排序的稳定性取决于寻找中间位置的时要插入值和临时中间值的等号处理，不带等号稳定
	public static void bInsertionSort(int[] data) {

		int d, left, right, mid;
		for (int i = 1; i < data.length; i++) {
			d = data[i];
			left = 0;
			right = i - 1;
			while (left <= right) {
				mid = (left + right) / 2;
				if (d < data[mid]) {
					right = mid - 1;
				} else {
					left = mid + 1;
				}
			}
			for (int j = i - 1; j >= left; j--) {
				data[j + 1] = data[j];
			}
			data[left] = d;
		}
		System.out.println("二分插入排序 " + Arrays.toString(data));
	}

	// 希尔排序（递减增量排序/跳跃直接插入排序），复杂度取决于步长，最最差复杂度为n方，时间复杂度下界为nlogn
	// 不稳定排序，不稳定的很显然
	public static void shellSort(int[] data) {

		int gap = 5, d;
		while (gap > 0) {

			for (int i = gap; i < data.length; i += gap) {
				d = data[i];
				for (int j = i; j > 0; j -= gap) {
					if (data[j] < data[j - gap]) {
						data[j] = data[j - gap];
						data[j - gap] = d;
					}
				}
			}
			gap--;
		}
		System.out.println("希尔排序 " + Arrays.toString(data));
	}

	// 选择排序,最好n方，最差n方，时间复杂度为n方
	// 选择排序是不稳定排序
	public static void selectionSort(int[] data) {

		int min, d = -1;
		for (int i = 0; i < data.length - 1; i++) {
			min = data[i];
			for (int j = i + 1; j < data.length; j++) {
				if (min > data[j]) {
					min = data[j];
					d = j;
				}
			}
			if (d == -1) {
			} else {
				data[d] = data[i];
				data[i] = min;
			}
		}
		System.out.println("选择排序 " + Arrays.toString(data));
	}

	// 冒泡排序，最好n，最差n方，时间复杂度n方
	// 冒泡排序的稳定性取决于相邻两元素比较时对等号的处理，不带等号稳定
	public static void bubbleSort(int[] data) {

		boolean isBubble = true;
		int tmp;
		while (isBubble) {
			isBubble = false;
			for (int i = 1; i < data.length; i++) {
				if (data[i] < data[i - 1]) {
					isBubble = true;
					tmp = data[i];
					data[i] = data[i - 1];
					data[i - 1] = tmp;
				}
			}
		}
		System.out.println("冒泡排序 " + Arrays.toString(data));
	}

	// 鸡尾酒排序（双向冒泡排序），最好n，最差n方
	// 鸡尾酒排序的稳定性取决于相邻元素比较时对等号的处理，不带等号稳定
	public static void cocktailSort(int[] data) {

		int head = 0;
		int tail = data.length;
		int tmp;
		boolean isBubble = true;
		for (; head < tail;) {

			isBubble = false;
			for (int i = head + 1; i < tail; i++) {
				if (data[i] < data[i - 1]) {
					isBubble = true;
					tmp = data[i];
					data[i] = data[i - 1];
					data[i - 1] = tmp;
				}
			}
			if (!isBubble)
				break;
			tail--;
			for (int i = tail; i > head; i--) {
				if (data[i] < data[i - 1]) {
					isBubble = true;
					tmp = data[i];
					data[i] = data[i - 1];
					data[i - 1] = tmp;
				}
			}
			if (!isBubble)
				break;
			head++;
		}

		System.out.println("双向冒泡排序 " + Arrays.toString(data));
	}

	/// 重点排序算法分界线//

	/**
	 * 快排
	 * 
	 * @param data
	 *            要拍的数组
	 * @param left
	 *            左限下标
	 * @param right
	 *            右限下标
	 */
	// 快速排序，最好nlogn，最差n方，平均时间复杂度nlogn
	// 不稳定排序
	// 是数组长度大于10后最理想的排序算法
	public static void quickSort(int[] data, int left, int right) {

		int i, j, base;
		if (left < right) {

			i = left;
			j = right;
			base = data[i];
			do {
				// 从右向左找到第一个小于基准值的下标
				while (data[j] > base && i < j) {
					j--;
				}
				// 上边的循环停掉可能是找到了一个值比基准值小，也可能是i==j了
				// 如果不是i==j，则接着往下走
				if (i < j) {
					data[i] = data[j];
					i++;
				}
				while (data[i] < base && i < j) {
					i++;
				}
				if (i < j) {
					data[j] = data[i];
					j--;
				}
			} while (i != j);
			data[i] = base;
			quickSort(data, left, i - 1);
			quickSort(data, i + 1, right);
		}

	}

	// 堆排序
	// 先建堆
	// 堆排序：将data[0]与data[n-1]交换，之后对data[0->n-2]作堆调整，重复此过程，直到data[0]与data[1]作交换
	// 堆排序是不稳定排序，时间复杂度（最差、最好、平均）为：nlogn
	// 堆排序的代码，呃，应该不会让你手写代码的

	// 归并排序，时间复杂度为nlogn，是一种比较高效的排序算法
	// 归并排序是一种稳定的排序方式
	public static void mergeSort(int[] data, int first, int last) {

		if (first < last) {
			int mid = (first + last) / 2;
			mergeSort(data, first, mid); // 左边有序
			mergeSort(data, mid + 1, last); // 右边有序
			mergeArray(data, first, mid, last); // 合并左右
		}

	}

	// 有空间复杂度消耗
	private static void mergeArray(int[] data, int first, int mid, int last) {
		int[] tmp = new int[last - first + 1];
		int tmp_idx = 0;
		int i = first, j = mid + 1;
		int m = mid, n = last;
		while (i <= m && j <= n) {
			if (data[i] < data[j]) {
				tmp[tmp_idx] = data[i];
				tmp_idx++;
				i++;
			} else {
				tmp[tmp_idx] = data[j];
				tmp_idx++;
				j++;
			}
		}
		while (i <= m) {
			tmp[tmp_idx] = data[i];
			tmp_idx++;
			i++;
		}
		while (j <= n) {
			tmp[tmp_idx] = data[j];
			tmp_idx++;
			j++;
		}
		tmp_idx = 0;
		for (; tmp_idx < tmp.length; tmp_idx++) {
			data[first + tmp_idx] = tmp[tmp_idx];
		}
	}

	// 桶排序（基数排序/箱排序）
	// 计数排序
}