三大基本排序算法
快排与快排切分
public class quickSort {
public static void quickSort ( int [ ] array, int L, int R) {
if ( L >= R) {
return ;
}
int left = L, right = R;
int pivot = array[ left] ;
while ( left < right) {
while ( left < right && array[ right] >= pivot ) right-- ;
if ( left < right) array[ left] = array[ right] ;
while ( left < right && array[ left] <= pivot) left++ ;
if ( left < right) array[ right] = array[ left] ;
if ( left >= right) array[ left] = pivot;
}
quickSort ( array, L, left- 1 ) ;
quickSort ( array, right+ 1 , R) ;
}
public static int [ ] getTopNumbers ( int [ ] array , int k) {
if ( k == 0 ) {
return new int [ 0 ] ;
} else if ( k >= array. length) {
return array;
}
quickSortK ( array, 0 , array. length- 1 , k) ;
int [ ] res = new int [ k] ;
for ( int i = 0 ; i < k; i++ ) {
res[ i] = array[ i] ;
}
return res;
}
public static void quickSortK ( int [ ] array, int L, int R, int K) {
if ( L >= R ) {
return ;
}
int left = L, right = R;
int pivot = array[ left] ;
while ( left< right) {
while ( left < right && array[ right] >= pivot) right-- ;
if ( left < right ) array[ left] = array[ right] ;
while ( left < right && array[ left] <= pivot) left++ ;
if ( left < right) array[ right] = array[ left] ;
if ( left >= right) array[ left] = pivot;
}
if ( K < left) quickSortK ( array, L, left- 1 , K) ;
else if ( K == left) return ;
else {
quickSortK ( array, L, left- 1 , K) ;
quickSortK ( array, right+ 1 , R, K) ;
}
}
public static void main ( String[ ] args) {
int [ ] array= { 10 , 2 , 34 , 43 , 155 , 6 , 7 , 90 , 3 } ;
quickSort ( array, 0 , array. length- 1 ) ;
System. out. println ( Arrays. toString ( array) ) ;
System. out. println ( Arrays. toString ( getTopNumbers ( array, 3 ) ) ) ;
}
}
堆排序
public class heapSort {
public static void swap ( int [ ] tree, int i, int j ) {
int tmp = tree[ i] ;
tree[ i] = tree[ j] ;
tree[ j] = tmp;
}
public static void heapify ( int [ ] tree, int i , int n ) {
if ( i> n) return ;
int left = 2 * i + 1 ;
int rigth = 2 * i + 2 ;
int max = i;
if ( left < n && tree[ left] > tree[ max] ) max = left;
if ( rigth< n && tree[ rigth] > tree[ max] ) max = rigth;
if ( max != i ) {
swap ( tree, max, i) ;
heapify ( tree, max, n) ;
}
}
public static void buildHeap ( int [ ] tree, int n) {
int parent = ( n- 1 ) / 2 ;
for ( int i = parent; i >= 0 ; i-- ) {
heapify ( tree, i, n) ;
}
}
public static void heapSort ( int [ ] tree, int n) {
buildHeap ( tree, n) ;
for ( int i = n- 1 ; i >= 0 ; i-- ) {
swap ( tree, i, 0 ) ;
heapify ( tree, 0 , i) ;
}
}
public static void main ( String[ ] args) {
int [ ] array= { 10 , 2 , 34 , 43 , 155 , 6 , 7 , 90 , 3 } ;
heapSort ( array, array. length) ;
System. out. println ( Arrays. toString ( array) ) ;
}
}
归并排序
public class mergoSort {
public static void mergo ( int [ ] array, int left, int right) {
if ( left >= right) return ;
int mid = ( left+ right) / 2 ;
mergo ( array, left, mid) ;
mergo ( array, mid+ 1 , right) ;
mergosort ( array, left, right, mid+ 1 ) ;
}
public static void mergosort ( int [ ] array, int left, int right, int mid) {
int [ ] tmp = new int [ array. length] ;
int p1 = left, p2= mid;
int tmp_p= left;
while ( p1 < mid && p2 <= right) {
if ( array[ p1] < array[ p2] ) {
tmp[ tmp_p++ ] = array[ p1++ ] ;
} else {
tmp[ tmp_p++ ] = array[ p2++ ] ;
}
}
while ( p1 < mid) {
tmp[ tmp_p++ ] = array[ p1++ ] ;
}
while ( p2 <= right) {
tmp[ tmp_p++ ] = array[ p2++ ] ;
}
for ( int i = left; i <= right ; i++ ) {
array[ i] = tmp[ i] ;
}
}
public static void main ( String[ ] args) {
int [ ] array= { 10 , 2 , 34 , 43 , 155 , 6 , 7 , 90 , 3 } ;
mergo ( array, 0 , array. length- 1 ) ;
System. out. println ( Arrays. toString ( array) ) ;
}
}