最近查资料发现java排序挺有意思的，其中包含常见八种具有代表性的排序法；笔者觉得排序的功能重要，但更重要的是排序的思想；所以简单叙述一下常见排序方法名称，并用代码举例。
A.插入排序（直接插入排序、希尔排序）;
B.交换排序（冒泡排序、快速排序）;
C.选择排序（直接选择排序、堆排序）;
D.归并排序;
E.分配排序（基数排序）;
所需辅助空间最多：归并排序;
所需辅助空间最少：堆排序;
平均速度最快：快速排序;
不稳定：快速排序，希尔排序，堆排序。
代码块：
package com.sinolife.mtrs.apply.controller;
import java.util.Arrays;
/**
* @author delin Li
* @version createTime：2017-12-7下午04:10:37
* @Description
*/
public class TestSort {
/**
* @param args
*/
public static void main(String[] args) {
int[] ins = {1,3,53,7,81,2,5,71,9};
// insertSort(ins);//直接插入排序
// shellSort(ins);//希尔排序，
// sampleSelectSort(ins);//简单选择排序
// heapSort(ins);//堆排序
// bubbleSort(ins);//冒泡 排序
// quikSort(ins,0,ins.length-1);//快速排序
// mergeSort(ins,0,ins.length-1);//归并排序
radixSort(ins,10,2);//基排序
print(ins);
}
public static void print(int[] data) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}
//直接插入排序
/*public static void insertSort(int arg[]){
for(int i=1;i<arg.length;i++){//将第一个数当做已经排好序的值，然后将后边无序数依次插入到已经排好的列表中
int j;
int temp = arg[i];//插入的数值
for(j=i;temp<arg[j-1]&&j>0;j--){
arg[j] = arg[j-1];////通过循环，逐个后移一位找到要插入的位置。
}
arg[j]=temp;//插入
}
}*/
//希尔
/*public static void shellSort(int a[]){
int n = a.length;
for(int i = n/2;i>0; i /=2){
for(int j = i;j<n;j++){//每个元素与自己组内的数据进行直接插入排序
if(a[j]<a[j-i]){
int temp = a[j];
int k = j-i;
while(k>=0&&a[k]>temp){
a[k+i] = a[k];
k -=i;
}
a[k+i] = temp;
}
}
}
}*/
//简单选择排序
/*public static void sampleSelectSort(int[] a){
int minV;//临时保存最小值
int minI;//临时保存最小值下标
for(int i= 0;i<a.length-1;i++){
minV = a[i];
minI = i;
for(int j = i+1;j<a.length;j++){
if(a[j]<minV){
minV = a[j];
minI = j;
}
}
if(minV != a[i] && minI !=i){
a[minI] = a[i];
a[i] = minV;
}
}
}*/
//堆排序
/*public static void swap(int[] data, int i, int j) {
if (i == j) {
return;
}
data[i] = data[i] + data[j];
data[j] = data[i] - data[j];
data[i] = data[i] - data[j];
}
public static void heapSort(int[] data) {
for (int i = 0; i < data.length; i++) {
createMaxdHeap(data, data.length - 1 - i);
swap(data, 0, data.length - 1 - i);
print(data);
}
}
public static void createMaxdHeap(int[] data, int lastIndex) {
for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
// 保存当前正在判断的节点
int k = i;
// 若当前节点的子节点存在
while (2 * k + 1 <= lastIndex) {
// biggerIndex总是记录较大节点的值,先赋值为当前判断节点的左子节点
int biggerIndex = 2 * k + 1;
if (biggerIndex < lastIndex) {
// 若右子节点存在，否则此时biggerIndex应该等于 lastIndex
if (data[biggerIndex] < data[biggerIndex + 1]) {
// 若右子节点值比左子节点值大，则biggerIndex记录的是右子节点的值
biggerIndex++;
}
}
if (data[k] < data[biggerIndex]) {
// 若当前节点值比子节点最大值小，则交换2者得值，交换后将biggerIndex值赋值给k
swap(data, k, biggerIndex);
k = biggerIndex;
} else {
break;
}
}
}
}*/
//冒泡排序
/*public static void bubbleSort(int[] a){
for (int i = 0; i < a.length-1; i++) {
for (int j = i; j < a.length-i-1; j++) {
if(a[j]>a[j+1]){
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}*/
//快速排序
/*public static void quikSort(int data[], int start, int end) {
if (end - start <= 0) {
return;
}
int last = start;
for (int i = start + 1; i <= end; i++) {
if (data[i] < data[start]) {
int temp = data[++last];
data[last] = data[i];
data[i] = temp;
}
}
int temp = data[last];
data[last] = data[start];
data[start] = temp;
quikSort(data, start, last - 1);
quikSort(data, last + 1, end);
}*/
//归并排序
/*public static void mergeSort(int data[], int start, int end) {
if (start < end) {
int mid = (start + end) / 2;
mergeSort(data, start, mid);
mergeSort(data, mid + 1, end);
merge(data, start, mid, end);
}
}
public static void merge(int data[], int start, int mid, int end) {
int temp[] = new int[end - start + 1];
int i = start;
int j = mid + 1;
int k = 0;
while (i <= mid && j <= end) {
if (data[i] < data[j]) {
temp[k++] = data[i++];
} else {
temp[k++] = data[j++];
}
}
while (i <= mid) {
temp[k++] = data[i++];
}
while (j <= end) {
temp[k++] = data[j++];
}
for (k = 0, i = start; k < temp.length; k++, i++) {
data[i] = temp[k];
}
}*/
//基排序
public static void radixSort(int[] data, int radix, int d) {
// 缓存数组
int[] tmp = new int[data.length];
// buckets用于记录待排序元素的信息
// buckets数组定义了max-min个桶
int[] buckets = new int[radix];
for (int i = 0, rate = 1; i < d; i++) {
// 重置count数组，开始统计下一个关键字
Arrays.fill(buckets, 0);
// 将data中的元素完全复制到tmp数组中
System.arraycopy(data, 0, tmp, 0, data.length);
// 计算每个待排序数据的子关键字
for (int j = 0; j < data.length; j++) {
int subKey = (tmp[j] / rate) % radix;
buckets[subKey]++;
}
for (int j = 1; j < radix; j++) {
buckets[j] = buckets[j] + buckets[j - 1];
}
// 按子关键字对指定的数据进行排序
for (int m = data.length - 1; m >= 0; m--) {
int subKey = (tmp[m] / rate) % radix;
data[--buckets[subKey]] = tmp[m];
}
rate *= radix;
}
}
}
如有错误，请朋友们提出！