基本排序算法（全）

7个基本排序算法：

冒泡，选择，插入
快排，归并，堆
桶
已实际运行过

冒泡：时间复杂度O(n^2)
选择：同上
插入：数据基本有序的情况下O(n)能达到桶排序速度，  平均和坏的时间复杂度为O(n^2)

快排： 平均性能比较好的O(nlog2N)
归并： 需要额外的空间辅助
堆：3个部件： 建堆，排序，下滑

桶：最快的，对某些特定问题，数据在一定范围内的。

import java.util.Arrays;
public class SortsDemo {
public static int N=50000;  //数据的数目
public static int M=10000; //数据的范围
public static int[] data=new int
;
public static void main(String[] args){
init();
//printData();
long startTime=System.currentTimeMillis();  //用于测试性能
//O(n^2)
//BubbleSort();
//selectSort();
//insetSort();
//O(log2(N))
//quickSort(0, data.length-1);
//MergeSort(0, data.length-1);
//HeapSort();
//O(n)
//bucketSort();
//printData();
System.out.println(System.currentTimeMillis()-startTime);
}
//数据初始化，随机生成数据
public static void init()
{
for (int i = 0; i < data.length; i++) {
data[i]=(int) (Math.random()*100);
}
}
public static void BubbleSort(){
for(int i=0;i<N-1;i++){
for (int j = 0; j < N-i-1; j++) {
if(data[j]>data[j+1])
{
//交换2个数
data[j]=data[j]^data[j+1];
data[j+1]=data[j]^data[j+1];
data[j]=data[j]^data[j+1];
}
}
}
}

public static void selectSort(){
for(int i=0;i<N;i++){
for (int j = i+1; j < N; j++) {
if(data[i]>data[j])
{
data[i]=data[i]^data[j];
data[j]=data[i]^data[j];
data[i]=data[i]^data[j];
}
}
}
}

public static void insetSort(){
int i,j;
for (i = 1; i < data.length; i++) {
int temp=data[i];
for (j = i-1; j >=0; j--) {
if(temp<data[j])
{
data[j+1]=data[j];
}else{
break;
}
}
data[j+1]=temp;
}

public static void quickSort(int left,int right){
if(left>right)
return;
int temp=data[left];//最左边的为基数，划分左右
int i=left;
int j=right;
while(i!=j)
{
while(data[j]>=temp&&i<j)
{
j--;
}
while(data[i]<=temp&&i<j)
{
i++;
}
if(i<j)
{
data[i]=data[i]^data[j];
data[j]=data[i]^data[j];
data[i]=data[i]^data[j];

}
}
data[left]=data[i];
data[i]=temp;
quickSort(left, i-1);
quickSort(i+1, right);
return;
}

public static void MergeSort(int m, int n){
if (m != n) {
int q = (m + n) / 2;
MergeSort(m, q);
MergeSort(q+1, n);
Merge(m, n);
}

private static void Merge(int m, int n) {
// TODO Auto-generated method stub
//  System.out.println("--m"+m+"--n"+n);
int q = (m + n) / 2;
int[] left = new int[q - m+2 ];
int[] right = new int[n - q+1];
left[0]=0;
right[0]=0;
for (int i = 1; i < left.length; i++) {
left[i]=data[i+m-1];
}
for (int i = 1; i < right.length; i++) {
right[i]=data[i+q];
}
int i = 1;//新 左边数组
int j = 1;//新右边数组
int index = m;//原始数据数组索引
while (i < left.length && j < right.length) {
if (left[i] < right[j]) {
data[index] = left[i];
i++;
index++;
} else {
data[index] = right[j];
j++;
index++;
}
}
if (i < left.length) {
while (i < left.length) {
data[index] = left[i];
index++;
i++;
}
}
if (j < right.length) {
while (j < right.length) {
data[index] = right[j];
index++;
j++;
}
}
}

public static void HeapSort(){
int heapData[]=new int[data.length+1];
for (int i = 1; i < heapData.length; i++) {
heapData[i]=data[i-1];
}
for (int i = heapData.length/2; i>=1; i--) {
//System.out.println("i"+i);
swiftDown(heapData,i,heapData.length-1);
}
for (int i = 1; i <= heapData.length-1; i++) {
int length=heapData.length-i;//边界索引

//边界的数和第一个数交换
heapData[1]=heapData[1]^heapData[length];
heapData[length]=heapData[1]^heapData[length];
heapData[1]=heapData[1]^heapData[length];

swiftDown(heapData, 1, length-1);
}
//for (int i = heapData.length-1; i >= 1; i--) {
//System.out.print(heapData[i]+",");
//}
}
/**
* @param heapData  数据
* @param i  下滑数据索引
* @param length  边界长度，即 有效数据
*/
public static void swiftDown(int[] heapData,int i,int length)
{
//下滑操作

int temp=heapData[i];
int leftChild=2*i<=length?heapData[2*i]:Integer.MAX_VALUE;
int rightChild=(2*i+1)<=length?heapData[2*i+1]:Integer.MAX_VALUE;
if(leftChild<=rightChild){
if(leftChild<=temp){
heapData[i]=leftChild;
heapData[2*i]=temp;
swiftDown(heapData, 2*i,length);
}
}else{
if(rightChild<=temp){
heapData[i]=rightChild;
heapData[i*2+1]=temp;
swiftDown(heapData, 2*i+1,length);
}
}
}
public static void bucketSort(){
int[] buckets=new int[M+1];
for (int i = 0; i < buckets.length; i++) {
buckets[i]=0;
}
for (int i = 0; i < N; i++) {
buckets[data[i]]++;
}
//  for (int i = 0; i < buckets.length; i++) {
//  for (int j = 0; j < buckets[i]; j++) {
//  System.out.print(i+",");
//    }
//  }
}

public static void printData(){
System.out.println(Arrays.toString(data));
}
}