最近查資料發現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;
}

}

}

如有錯誤，請朋友們提出！

java常用八大排序法