八大排序算法
文字说明部分转载自http://blog.csdn.net/hguisu/article/details/7776068
排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
我们这里说说八大排序就是内部排序。
当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。
快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
**（1）直接插入排序：一般插入排序，比较是从有序序列的最后一个元素开始，如果比它大则直接插入在其后面，否则一直往前比。如果找到一个和插入元素相等的，那么就插入到这个相等元素的后面。插入排序是稳定的。
（2）希尔排序：希尔排序是按照不同步长对元素进行插入排序，一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，稳定性就会被破坏，所以希尔排序不稳定。
（3）简单选择排序：在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。光说可能有点模糊，来看个小实例：858410，第一遍扫描，第1个元素8会和4交换，那么原序列中2个8的相对前后顺序和原序列不一致了，所以选择排序不稳定。
（4）堆排序：堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n/2-1, n/2-2, …这些父节点选择元素时，有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，所以堆排序并不稳定。
（5）冒泡排序：由前面的内容可知，冒泡排序是相邻的两个元素比较，交换也发生在这两个元素之间，如果两个元素相等，不用交换。所以冒泡排序稳定。
（6）快速排序：在中枢元素和序列中一个元素交换的时候，很有可能把前面的元素的稳定性打乱。还是看一个小实例：6 4 4 5 4 7 8 9，第一趟排序，中枢元素6和第三个4交换就会把元素4的原序列破坏，所以快速排序不稳定。
（7）归并排序：在分解的子列中，有1个或2个元素时，1个元素不会交换，2个元素如果大小相等也不会交换。在序列合并的过程中，如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，所以，归并排序也是稳定的。
（8）基数排序：是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。
8种排序的分类，稳定性，时间复杂度和空间复杂度总结：
**
package Sort_eight;
public class sort {
public static void main(String[] args) {
int[] array1 = { 46, 24, 76, 98, 14, 7, 58 };
System.out.println("插入排序：-直接插入--n^2");
insertSort(array1, array1.length);
System.out.println("-----------");
System.out.println("插入排序：-希尔排序");
int[] array2 = { 46, 24, 76, 98, 14, 7, 58 };
shellInsertSort(array2,array2.length);
System.out.println("-----------");
System.out.println("交换排序：-冒泡排序");
int[] array3 = { 46, 24, 76, 98, 14, 7, 58 };
bubbleSort(array3,array3.length);
System.out.println("-----------");
System.out.println("交换排序：-快速排序");
int[] array4 = { 46, 24, 76, 98, 14, 7, 58 };
quickSort(array4,array4.length);
System.out.println("-----------");
System.out.println("选择排序：-简单选择排序");
int[] array5 = { 46, 24, 76, 98, 14, 7, 58 };
simpleSelectSort(array5,array5.length);
System.out.println("-----------");
System.out.println("选择排序：-堆排序");
int[] array6 = { 46, 24, 76, 98, 14, 7, 58 };
shellInsertSort(array6,array6.length);
System.out.println("-----------");
System.out.println("二路归并排序");
int[] array7 = { 46, 24, 76, 98, 14, 7, 58 };
mergeSort(array7,0,array7.length-1);
print(array7);
System.out.println("-----------");
System.out.println("桶/基数排序");
int[] array8 = { 46, 24, 76, 98, 14, 7, 58 };
radixSort(array8,100);
System.out.println("-----------");
}
//1.插入排序—直接插入排序(Straight Insertion Sort)---n^2
public static void insertSort(int[] array, int length) {
// TODO Auto-generated method stub
if (array != null) {
for (int i = 1; i < length; i++) {
if (array[i] < array[i - 1]) {
int temp = array[i], j = i;
while (j >= 1 && array[j - 1] > temp) {
array[j] = array[j - 1];
j--;
}
array[j] = temp;
}
}
}
print(array);
}
//2. 插入排序—希尔排序（Shell`s Sort）---n*logn
//-又叫缩小增量排序
public static void shellInsertSort(int[] array, int length) {
// TODO Auto-generated method stub
for(int gap=length/2;gap>0;gap/=2){
for(int i=gap;i<length;i++){
for(int j=i-gap;j>=0&&array[j]>array[j+gap];j=j-gap){
swap(array,j,j+gap);
}
}
}
print(array);
}
//3.交换排序—冒泡排序（Bubble Sort）-----n^2
private static void bubbleSort(int[] array, int length) {
// TODO Auto-generated method stub
for(int i=0;i<length-1;i++){
for(int j=length-1;j>i;j--){
if(array[j]<array[j-1]){
swap(array, j-1, j);
}
}
}
print(array);
}
//4.交换排序—快速排序（Bubble Sort）在复习一下！！！！
private static void quickSort(int[] array, int length) {
// TODO Auto-generated method stub
qSort(array,0,length-1);
print(array);
}
private static void qSort(int[] array, int low, int high) {
// TODO Auto-generated method stub
int i = low, j = high, index;
if (low >= high)
return;
index = array[i];
while (i < j) {
while (i < j && array[j] >= index) {
j--;
}
if (i < j) {
array[i] = array[j];
i++;
}
while (i < j && array[i] < index) {
i++;
}
if (i < j) {
array[j] = array[i];
j--;
}
}
array[i] = index;
qSort(array, low, i - 1);
qSort(array, i + 1, high);
}
//5.交换排序—简单选择排序（Bubble Sort）
private static void simpleSelectSort(int[] array, int length) {
// TODO Auto-generated method stub
for(int i=0;i<length;i++){
int indexmin=array[i];
for(int j=i+1;j<length;j++){
if(array[j]<indexmin){
int temp=indexmin;
indexmin=array[j];
array[j]=temp;
}
}
array[i]=indexmin;
}
print(array);
}
//6.交换排序—堆排序（Bubble Sort）
private static void heapSort(int[] array, int length) {
// TODO Auto-generated method stub
//暂时未看懂--
}
// 7.交换排序—二路归并排序（Bubble Sort）
private static void mergeSort(int[] array, int low, int high) {
// TODO Auto-generated method stub
if (low < high) {
int mid = (low + high) / 2;
mergeSort(array, low, mid);
mergeSort(array, mid + 1, high);
merge(array, low, mid, high);
}
}
private static void merge(int[] array, int low, int mid, int high) {
// TODO Auto-generated method stub
int n1=mid-low+1,n2=high-mid;
int i=0,j=0,k=0;
int[] l=new int[n1];
int[] h=new int[n2];
for(i=0, k=low;i<n1;k++,i++){
l[i]=array[k];
}
for(k=mid+1,i=0;i<n2;k++,i++){
h[i]=array[k];
}
for(i=0,j=0,k=low;i<n1&&j<n2;k++){
if(l[i]<h[j]){
array[k]=l[i];
i++;
}
else{
array[k]=h[j];
j++;
}
}
if(i<n1){
for(j=i;j<n1;j++,k++){
array[k]=l[j];
}
}
if(j<n2){
for(i=j;i<n2;i++,k++){
array[k]=h[i];
}
}
}
// 8.交换排序—桶/基数排序（Bubble Sort）
private static void radixSort(int[] array,int d) {
// TODO Auto-generated method stub
int n = 1, length = array.length;
int index = 0,k=0;
int[][] bucket = new int[10][length];
int[] number = new int[10];
while (n < d) {
for (int num : array) {
index = (num / n) % 10;
bucket[index][number[index]] = num;
number[index]++;
}
for (int i = 0; i < 10; i++) {
if (number[i] != 0) {
for (int j = 0; j < number[i]; j++) {
array[k++] = bucket[i][j];
}
}
number[i]=0;
}
n*=10;
k=0;
}
print(array);
}
public static void swap(int a[], int i, int j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
private static void print(int[] array) {
// TODO Auto-generated method stub
for (int number : array) {
System.out.print(number + " ");
}
}
}