1 冒泡排序(最大的先落底)
public static int [ ] bubbleSort ( int [ ] array) {
if ( array. length == 0 )
return array;
for ( int i = 0 ; i < array. length; i++ )
for ( int j = 0 ; j < array. length - 1 - i; j++ )
if ( array[ j + 1 ] < array[ j] ) {
int temp = array[ j + 1 ] ;
array[ j + 1 ] = array[ j] ;
array[ j] = temp;
}
return array;
}
2 选择排序 (每次从未排序中选中max或min)
public static int [ ] selectionSort ( int [ ] array) {
if ( array. length == 0 )
return array;
for ( int i = 0 ; i < array. length; i++ ) {
int minIndex = i;
for ( int j = i; j < array. length; j++ ) {
if ( array[ j] < array[ minIndex] )
minIndex = j;
}
int temp = array[ minIndex] ;
array[ minIndex] = array[ i] ;
array[ i] = temp;
}
return array;
}
3 插入排序 (对于未排序数据,在有序数组中从后向前查找到合适位置插入)
public static int [ ] insertionSort ( int [ ] array) {
if ( array. length == 0 )
return array;
int current;
for ( int i = 0 ; i < array. length - 1 ; i++ ) {
current = array[ i + 1 ] ;
int preIndex = i;
while ( preIndex >= 0 && current < array[ preIndex] ) {
array[ preIndex + 1 ] = array[ preIndex] ;
preIndex-- ;
}
array[ preIndex + 1 ] = current;
}
return array;
}
4 希尔排序(缩小增量排序:记录按一定规则增量分组后排序,直至增量步长为1,则为全数组排序)
public static int [ ] ShellSort ( int [ ] array) {
int len = array. length;
int temp, gap = len / 2 ;
while ( gap > 0 ) {
for ( int i = gap; i < len; i++ ) {
temp = array[ i] ;
int preIndex = i - gap;
while ( preIndex >= 0 && array[ preIndex] > temp) {
array[ preIndex + gap] = array[ preIndex] ;
preIndex -= gap;
}
array[ preIndex + gap] = temp;
}
gap /= 2 ;
}
return array;
}
5 归并排序 (将已有序的子序列进行合并,得到完全有序数组)
public static int [ ] MergeSort ( int [ ] array) {
if ( array. length < 2 ) return array;
int mid = array. length / 2 ;
int [ ] left = Arrays. copyOfRange ( array, 0 , mid) ;
int [ ] right = Arrays. copyOfRange ( array, mid, array. length) ;
return merge ( MergeSort ( left) , MergeSort ( right) ) ;
}
public static int [ ] merge ( int [ ] left, int [ ] right) {
int [ ] result = new int [ left. length + right. length] ;
for ( int index = 0 , i = 0 , j = 0 ; index < result. length; index++ ) {
if ( i >= left. length)
result[ index] = right[ j++ ] ;
else if ( j >= right. length)
result[ index] = left[ i++ ] ;
else if ( left[ i] > right[ j] )
result[ index] = right[ j++ ] ;
else
result[ index] = left[ i++ ] ;
}
return result;
}
6 快速排序 (将待排序的数组分成二组,一组的关键字均大于另一组)
public static int [ ] QuickSort ( int [ ] array, int start, int end) {
if ( array. length < 1 || start < 0 || end >= array. length || start > end) return null;
int smallIndex = partition ( array, start, end) ;
if ( smallIndex > start)
QuickSort ( array, start, smallIndex - 1 ) ;
if ( smallIndex < end)
QuickSort ( array, smallIndex + 1 , end) ;
return array;
}
int partition ( int [ ] a, int lo, int hi) {
int i = lo;
int j = hi + 1 ;
int v = a[ lo] ;
while ( true ) {
while ( a[ ++ i] < v) {
if ( i == hi) {
break ;
}
}
while ( a[ -- j] > v) {
if ( j == lo) {
break ;
}
}
if ( i >= j) {
break ;
}
swap ( a, i, j) ;
}
swap ( a, lo, j) ;
return j;
}
void swap ( int [ ] a, int i, int j) {
int temp = a[ i] ;
a[ i] = a[ j] ;
a[ j] = temp;
}
7 堆排序
static int len;
public static int [ ] HeapSort ( int [ ] array) {
len = array. length;
if ( len < 1 ) return array;
buildMaxHeap ( array) ;
while ( len > 0 ) {
swap ( array, 0 , len - 1 ) ;
len-- ;
adjustHeap ( array, 0 ) ;
}
return array;
}
public static void buildMaxHeap ( int [ ] array) {
for ( int i = ( len/ 2 - 1 ) ; i >= 0 ; i-- ) {
adjustHeap ( array, i) ;
}
}
public static void adjustHeap ( int [ ] array, int i) {
int maxIndex = i;
if ( i * 2 < len && array[ i * 2 ] > array[ maxIndex] )
maxIndex = i * 2 ;
if ( i * 2 + 1 < len && array[ i * 2 + 1 ] > array[ maxIndex] )
maxIndex = i * 2 + 1 ;
if ( maxIndex != i) {
swap ( array, maxIndex, i) ;
adjustHeap ( array, maxIndex) ;
}
}
8 计数排序
9 桶排序
10 基数排序