Java 排序算法

最近重温排序算法，对插入排序  希尔排序  选择排序  堆排序  快速排序  归并排序 重新学习了一下，并根据网上的资料和自己的测试 代码总结如下：

public static void main(String[] args) {

int[] _i1 = new int[]{5,4,3,2,1,8,9,7,6 , 15 , 19 , 2 , 56 ,94} ;

megersort(_i1);

print02(_i1);

}

private static void print01( int[] data ){
for( int _data : data ){
System.out.println(_data);
}
}

private static void print02( int[] data ){
for( int _data : data ){
System.out.print(_data + " ");
}
System.out.println("");
}


private static void test01( int i ){
System.out.println(i);
}

-------------------------------------------------------------------------------------------------------------
/**
* 插入排序
* @param data
*/
public static void insertSort( int[] data ){

int num = 0 ;

int tmp ; 
int j ;

for( int i = 1 ; i < data.length ; i++ ){
tmp = data[i] ;
for( j = i ; j > 0 && tmp < data[j-1] ; j-- ){
data[j] = data[j-1] ;
num ++ ;
}
data[j] = tmp ;
}

System.out.println("插入排序移动次数：" + String.valueOf(num));

}
-------------------------------------------------------------------------------------------------------------
/**
* 希尔排序  做为插入排序的升级  先将数组 按照数组长度的一半 分组   对分组进行插入排序   排序后继续分组  分组的长度为1 
* @param data
*/
public static void shellSort( int[] data ){
int num = 0 ;
int j = 0 ; 
int tmp = 0 ;
for( int in = data.length / 2  ; in > 0 ;  in /= 2 ){
for( int i = in ; i < data.length ; i++ ){
tmp = data[i] ;
for( j = i ; j >= in && tmp < data[j-in] ; j -= in ){
data[j] = data[j-in] ;
num ++ ;
}
data[j] = tmp ;
}
}
System.out.println("希尔排序移动次数：" + String.valueOf(num));
}

-------------------------------------------------------------------------------------------------------------
/**
* 选择排序
* @param data
*/
public static void selectSort( int[] data ){

int least ; 

for( int i = 0 ; i < data.length - 1 ; i++ ){
least = i ;
for( int j = i+1 ; j < data.length ; j++ ){
if( data[j] < data[least] ){
least = j ;
}
}
swap( data , i , least );
}

}

public static void swap( int[] data , int i , int j ){
int tmp = data[i];
data[i] = data[j] ;
data[j] = tmp ;


}
-------------------------------------------------------------------------------------------------------------
/**
* 冒泡排序
* @param data
*/
public static void bubbleSort( int[] data ){
for( int i = 0 ; i< data.length - 1 ; i++ ){
for( int j = data.length-1 ; j > i ; j--){
if( data[j] < data[j-1] ){
swap( data, j , j-1 );
}
}
}
}


/**
* base的 num次方 的计算方法
* @param base
* @param num
* @return
*/
public static int cj( int base , int num ){

if( num == 0 ){
return 1 ;
} else if( num == 1 ){
return base ;
}

int result = cj(base , num >> 1 ) ;
result *= result ;
if( (num & 0x1)  == 1 ){
result *= base ;
}
return result ;
}
-------------------------------------------------------------------------------------------------------------

       //堆排序
private static void heapPaixu(  int[] data ){

buildheap(data);  //先对数组构建最大堆

for( int _i21 : data ){
System.out.print(_i21 + "  ");
}

for( int i = data.length - 1 ; i > 0 ; i-- ){
swap( data , i , 0 ) ;
heapSize(data , i , 0);

}

}

private static void buildheap( int[] data ){
for( int i = data.length/2 ; i >= 0 ; i-- ){
heapSize( data , data.length , i);
}

}

private static void heapSize( int[] data , int heapsize , int index ){
int left = 2*index + 1 ;
int right = 2*index + 2 ;
int largest = index ;
if( left < heapsize && data[largest] < data[left] ){
largest = left ;
}
if( right < heapsize && data[largest] < data[right] ){
largest = right ;
}
if( largest != index ){
swap( data , largest , index );
heapSize( data , heapsize , largest );
}
}

-------------------------------------------------------------------------------------------------------------

       //快速排序
public static void quicksort( int[] data ){
quicksort( data , 0 , data.length -1 );
} 

/**
* 快速排序
* @param data
*/
public static void quicksort( int[] data , int first , int last){
int bound = data[first] ;
int low = first + 1 ;
int upper = last ;
while( low <= upper ){
while( data[low] < bound && low <= last ){
low++ ;
}
while( data[upper] > bound ){
upper-- ;
}
if( low < upper ){
swap( data , low++ , upper-- ) ;
}else{
low ++ ;
}
}

//此时upper为该分组中最后一个小于data[first]的数字,所以将枢轴与该数字进行交换
if( first != upper){
swap(data , first , upper);
}

print02(data);

if( first < upper - 1 ){
quicksort(data , first , upper-1);
}
if( upper+1 < last ){
quicksort(data , upper + 1  , last);
}

}
-------------------------------------------------------------------------------------------------------------
/**
* 归并排序
* 先将每个数组按照中位数 递归分成两个数组 直到每个数组元素个数为1
* 再将数组合并
* @param data
*/
private static void megersort( int[] data ){
megersort( data , 0 , data.length - 1 );
}

private static void megersort( int[] data  , int first , int last){
if( first < last ){
int mid = (first + last)/2 ;
megersort(data , first , mid) ;
megersort(data , mid+1 , last);
meger(data , first , last);
}
}

private static void meger( int[] data , int first , int last ){
int[] temp = new int[last - first + 1] ;
int mid = (first + last)/2 ;
int i1 = first ;
int i2 = mid + 1 ;
int i3 = 0 ;

while( i1 <= mid && i2 <= last ){
if( data[i1] <= data[i2] ){
temp[i3++] = data[i1++] ;
}

if( data[i1] >= data[i2] ){
temp[i3++] = data[i2++] ;
}

}

while( i1 <= mid ){
temp[i3++] = data[i1++] ;
}

while( i2 <= last ){
temp[i3++] = data[i2++] ;
}

for( int i = 0 ; i < temp.length ; i++ ){
data[i+first] = temp[i];
}

}