Java八大排序算法

Java八大排序算法：

package sort;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * mysort
 *
 * @author Arya
 *
 */
public class MySort {

	public static void main(String[] args) {
		MySort mySort = new MySort();
		mySort.insertSort();
		mySort.shellSort();
		mySort.selectSort();
		mySort.bubbleSort();
		mySort.quickSort();
		mySort.HeapSort();
		mySort.mergingSort();
		mySort.radixSort();
	}

	/**
	 * 直接插入排序：稳定 时间复杂度：最好O(n),其它O(n^2) 空间复杂度：O(1)
	 */
	public void insertSort() {
		int a[] = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62,
				99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51 };
		int temp = 0;
		for (int i = 1; i < a.length; ++i) {
			temp = a[i];
			int j = i - 1;
			for (; j >= 0 && temp < a[j]; --j) {
				a[j + 1] = a[j];
			}
			a[j + 1] = temp;
		}
		for (int i = 0; i < a.length; ++i)
			System.out.print(a[i] + "--");
		System.out.println();
	}

	/**
	 * 希尔排序：不稳定 时间复杂度：O(nlog2n)～O(n^2) 空间复杂度：O(1)
	 */
	public void shellSort() {
		int a[] = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62,
				99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51 };
		int d = a.length;
		int temp = 0;
		while (true) {
			d = (int) Math.ceil(d / 2);
			for (int x = 0; x < d; x++) {
				for (int i = x + d; i < a.length; i += d) {
					int j = i - d;
					temp = a[i];
					for (; j >= 0 && temp < a[j]; j -= d) {
						a[j + d] = a[j];
					}
					a[j + d] = temp;
				}
			}
			if (d == 1)
				break;
		}
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + "--");
		System.out.println();
	}

	/**
	 * 选择排序：不稳定 时间复杂度：O(n^2) 空间复杂度：O(1)
	 */
	public void selectSort() {
		int a[] = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62,
				99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51 };
		int position = 0;
		for (int i = 0; i < a.length; i++) {
			int j = i + 1;
			position = i;
			int temp = a[i];
			for (; j < a.length; j++) {
				if (a[j] < temp) {
					temp = a[j];
					position = j;
				}
			}
			a[position] = a[i];
			a[i] = temp;
		}
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + "--");
		System.out.println();
	}

	/**
	 * 冒泡排序：稳定 时间复杂度：最好O(n),其它O(n^2) 空间复杂度：O(1)
	 */
	public void bubbleSort() {
		int a[] = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62,
				99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51 };
		int temp = 0;
		int flag = 1;
		for (int i = 0; i < a.length - 1 && flag == 1; i++) {
			flag = 0;
			for (int j = 0; j < a.length - 1 - i; j++) {
				if (a[j] > a[j + 1]) {
					temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
					flag = 1;
				}
			}
		}
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + "--");
		System.out.println();
	}

	/**
	 * 快速排序：不稳定 时间复杂度：最好，平均O(nlog2n),最差O(n^2) 空间复杂度：O(log2n)
	 */
	public void quickSort() {
		int a[] = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62,
				99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51 };
		_quickSort(a, 0, a.length - 1);
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + "--");
		System.out.println();
	}

	public void _quickSort(int[] list, int low, int high) {
		if (low < high) {
			int middle = getMiddle(list, low, high);
			_quickSort(list, low, middle - 1);
			_quickSort(list, middle + 1, high);
		}
	}

	public int getMiddle(int[] list, int low, int high) {
		int tmp = list[low];
		while (low < high) {
			while (low < high && list[high] >= tmp) {

				high--;
			}
			list[low] = list[high];
			while (low < high && list[low] <= tmp) {
				low++;
			}
			list[high] = list[low];
		}
		list[low] = tmp;
		return low;
	}

	/**
	 * 堆排序：不稳定 时间复杂度：O(nlog2n) 空间复杂度：O(1)
	 */
	public void HeapSort() {
		int a[] = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62,
				99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51 };
		int n = a.length;
		int i;
		int temp;
		InitCreateHeap(a, n);
		for (i = n - 1; i > 0; i--) {
			temp = a[0];
			a[0] = a[i];
			a[i] = temp;

			CreateHeap(a, i, 0);
		}
		for (i = 0; i < a.length; i++)
			System.out.print(a[i] + "--");
		System.out.println();
	}

	public void InitCreateHeap(int a[], int n) {
		for (int i = (n - 1) / 2; i >= 0; i--)
			CreateHeap(a, n, i);
	}

	public void CreateHeap(int a[], int n, int h) {
		int i, j, flag;
		int temp;

		i = h;
		j = 2 * i + 1;
		flag = 0;
		temp = a[i];

		while (j < n && flag != 1) {
			if (j < n - 1 && a[j] < a[j + 1])
				j++;
			if (temp > a[j])
				flag = 1;
			else {
				a[i] = a[j];
				i = j;
				j = 2 * i + 1;
			}
		}
		a[i] = temp;
	}

	/**
	 * 归并排序：稳定 时间复杂度：O(nlog2n) 空间复杂度：O(n)
	 */
	public void mergingSort() {
		int a[] = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62,
				99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51 };
		sort(a, 0, a.length - 1);
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + "--");
		System.out.println();
	}

	public void sort(int[] data, int left, int right) {
		// TODO Auto-generated method stub
		if (left < right) {
			// 找出中间索引
			int center = (left + right) / 2;
			// 对左边数组进行递归
			sort(data, left, center);
			// 对右边数组进行递归
			sort(data, center + 1, right);
			// 合并
			merge(data, left, center, right);

		}
	}

	public void merge(int[] data, int left, int center, int right) {
		// TODO Auto-generated method stub
		int[] tmpArr = new int[data.length];
		int mid = center + 1;
		// third记录中间数组的索引
		int third = left;
		int tmp = left;
		while (left <= center && mid <= right) {

			// 从两个数组中取出最小的放入中间数组
			if (data[left] <= data[mid]) {
				tmpArr[third++] = data[left++];
			} else {
				tmpArr[third++] = data[mid++];
			}
		}
		// 剩余部分依次放入中间数组
		while (mid <= right) {
			tmpArr[third++] = data[mid++];
		}
		while (left <= center) {
			tmpArr[third++] = data[left++];
		}
		// 将中间数组中的内容复制回原数组
		while (tmp <= right) {
			data[tmp] = tmpArr[tmp++];
		}
		// System.out.println(Arrays.toString(data));
	}

	/**
	 * 基数排序：稳定 时间复杂度：O(kn)，其中n是排序元素个数，k是数字位数。 空间复杂度：O(kn)
	 */
	public void radixSort() {
		int a[] = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62,
				99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51 };
		sort(a);
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + "--");
		System.out.println();
	}

	public void sort(int[] array) {
		// 首先确定排序的趟数;
		int max = array[0];
		for (int i = 1; i < array.length; i++) {
			if (array[i] > max) {
				max = array[i];
			}
		}

		int time = 0;
		// 判断位数;
		while (max > 0) {
			max /= 10;
			time++;
		}

		// 建立10个队列;
		List<ArrayList> queue = new ArrayList<ArrayList>();
		for (int i = 0; i < 10; i++) {
			ArrayList<Integer> queue1 = new ArrayList<Integer>();
			queue.add(queue1);
		}

		// 进行time次分配和收集;
		for (int i = 0; i < time; i++) {

			// 分配数组元素;
			for (int j = 0; j < array.length; j++) {
				// 得到数字的第time+1位数;
				int x = array[j] % (int) Math.pow(10, i + 1)
						/ (int) Math.pow(10, i);
				ArrayList<Integer> queue2 = queue.get(x);
				queue2.add(array[j]);
				queue.set(x, queue2);
			}
			int count = 0;// 元素计数器;
			// 收集队列元素;
			for (int k = 0; k < 10; k++) {
				while (queue.get(k).size() > 0) {
					ArrayList<Integer> queue3 = queue.get(k);
					array[count] = queue3.get(0);
					queue3.remove(0);
					count++;
				}
			}
		}
	}

}