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++;
}
}
}
}
}