排序
import java. util. Arrays;
class BubbleSort {
public int [ ] bubbleSort ( int [ ] A, int n) {
for ( int i = 1 ; i < n; i++ ) {
for ( int j = 0 ; j < n - 1 ; j++ ) {
if ( A[ j] > A[ j + 1 ] ) {
int t = A[ j] ;
A[ j] = A[ j + 1 ] ;
A[ j + 1 ] = t;
}
}
}
return A;
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new BubbleSort ( ) . bubbleSort ( new int [ ] {
1 , 2 , 3 , 5 , 2 , 3 } , 6 ) ) ) ;
}
}
class SelectionSort {
public int [ ] selectionSort ( int [ ] A, int n) {
for ( int i = 0 ; i < n - 1 ; i++ ) {
int min = i;
for ( int j = i; j < n; j++ ) {
if ( A[ j] < A[ min] ) {
min = j;
}
}
int t = A[ min] ;
A[ min] = A[ i] ;
A[ i] = t;
}
return A;
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new SelectionSort ( ) . selectionSort ( new int [ ] {
1 , 2 , 3 , 5 , 2 , 3 } , 6 ) ) ) ;
}
}
class InsertionSort {
public int [ ] insertionSort ( int [ ] A, int n) {
for ( int i = 1 ; i < n; i++ ) {
int j = i - 1 ;
int t = A[ i] ;
while ( j >= 0 && A[ j] >= t) {
A[ j + 1 ] = A[ j] ;
j-- ;
}
A[ j + 1 ] = t;
}
return A;
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new InsertionSort ( ) . insertionSort ( new int [ ] {
1 , 2 , 3 , 5 , 2 , 3 } , 6 ) ) ) ;
}
}
class MergeSort {
public int [ ] mergeSort ( int [ ] A, int n) {
merge ( A, 0 , n - 1 ) ;
return A;
}
private void merge ( int [ ] A, int left, int right) {
if ( right - left <= 0 ) return ;
int mid = ( left + right) >> 1 ;
merge ( A, left, mid) ;
merge ( A, mid + 1 , right) ;
int i = left, j = mid + 1 ;
int [ ] B = new int [ right - left + 1 ] ;
int cnt = 0 ;
while ( i <= mid && j <= right) {
if ( A[ i] < A[ j] ) {
B[ cnt++ ] = A[ i++ ] ;
} else {
B[ cnt++ ] = A[ j++ ] ;
}
}
while ( i <= mid) {
B[ cnt++ ] = A[ i++ ] ;
}
while ( j <= right) {
B[ cnt++ ] = A[ j++ ] ;
}
for ( i = 0 ; i < B. length; i++ ) {
A[ left + i] = B[ i] ;
}
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new MergeSort ( ) . mergeSort ( new int [ ] {
1 , 2 , 3 , 5 , 2 , 3 } , 6 ) ) ) ;
}
}
class QuickSort {
public int [ ] quickSort ( int [ ] A, int n) {
qSort ( A, 0 , n - 1 ) ;
return A;
}
private void qSort ( int [ ] A, int left, int right) {
if ( right - left <= 0 ) return ;
int pos = partition ( A, left, right) ;
qSort ( A, left, pos - 1 ) ;
qSort ( A, pos + 1 , right) ;
}
private int partition ( int [ ] A, int left, int right) {
int i = left;
for ( int j = left; j < right; j++ ) {
if ( A[ j] < A[ right] ) {
int t = A[ j] ;
A[ j] = A[ i] ;
A[ i] = t;
i++ ;
}
}
int t = A[ right] ;
A[ right] = A[ i] ;
A[ i] = t;
return i;
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new QuickSort ( ) . quickSort ( new int [ ] {
1 , 2 , 3 , 5 , 2 , 3 } , 6 ) ) ) ;
}
}
class HeapSort {
public int [ ] heapSort ( int [ ] A, int n) {
buildMaxHeap ( A) ;
for ( int i = A. length - 1 ; i >= 1 ; i-- ) {
int t = A[ 0 ] ;
A[ 0 ] = A[ i] ;
A[ i] = t;
adjustDownToUp ( A, 0 , i) ;
}
return A;
}
private void buildMaxHeap ( int [ ] A) {
for ( int i = ( A. length - 2 ) / 2 ; i >= 0 ; i-- ) {
adjustDownToUp ( A, i, A. length) ;
}
}
private void adjustDownToUp ( int [ ] A, int k, int length) {
int t = A[ k] ;
for ( int i = 2 * k + 1 ; i < length; i = 2 * i + 1 ) {
if ( i < length - 1 && A[ i] < A[ i + 1 ] ) {
i++ ;
}
if ( t >= A[ i] ) {
break ;
}
A[ k] = A[ i] ;
k = i;
}
A[ k] = t;
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new HeapSort ( ) . heapSort ( new int [ ] {
1 , 2 , 3 , 5 , 2 , 3 } , 6 ) ) ) ;
}
}
class ShellSort {
public int [ ] shellSort ( int [ ] A, int n) {
for ( int i = n / 2 ; i >= 1 ; i /= 2 ) {
insertSort ( A, i) ;
}
return A;
}
private void insertSort ( int [ ] A, int step) {
for ( int i = step; i < A. length; i++ ) {
int t = A[ i] ;
int j = i - step;
while ( j >= 0 && A[ j] >= t) {
A[ j + step] = A[ j] ;
j -= step;
}
j += step;
A[ j] = t;
}
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new ShellSort ( ) . shellSort ( new int [ ] {
1 , 2 , 3 , 5 , 2 , 3 } , 6 ) ) ) ;
}
}
class CountingSort {
public int [ ] countingSort ( int [ ] A, int n) {
int max = A[ 0 ] ;
for ( int i = 1 ; i < n; i++ ) {
max = Math. max ( max, A[ i] ) ;
}
int [ ] c = new int [ max + 1 ] ;
Arrays. fill ( c, 0 ) ;
for ( int i = 0 ; i < n; i++ ) {
c[ A[ i] ] ++ ;
}
int cnt = 0 ;
for ( int i = 0 ; i <= max; i++ ) {
while ( c[ i] > 0 ) {
A[ cnt++ ] = i;
c[ i] -- ;
}
}
return A;
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new CountingSort ( ) . countingSort ( new int [ ] {
1 , 2 , 3 , 5 , 2 , 3 } , 6 ) ) ) ;
}
}
class RadixSort {
public int [ ] radixSort ( int [ ] A, int n) {
int max = 0 ;
for ( int i = 0 ; i < n; i++ ) {
max = Math. max ( max, Integer. toString ( A[ i] ) . length ( ) ) ;
}
int [ ] [ ] r = new int [ 10 ] [ A. length+ 1 ] ;
initArray ( r) ;
for ( int i = 0 ; i < max; i++ ) {
sortByBit ( r, A, i) ;
initArray ( r) ;
}
return A;
}
private void initArray ( int [ ] [ ] r) {
for ( int i = 0 ; i < 10 ; i++ ) {
r[ i] [ 0 ] = 0 ;
for ( int j = 1 ; j < r[ i] . length; j++ ) {
r[ i] [ j] = - 1 ;
}
}
}
private void sortByBit ( int [ ] [ ] r, int [ ] A, int t) {
for ( int i = 0 ; i < A. length; i++ ) {
int v = getValueAt ( A[ i] , t) ;
int cnt = r[ v] [ 0 ] ;
r[ v] [ ++ cnt] = A[ i] ;
r[ v] [ 0 ] = cnt;
}
int k = 0 ;
for ( int i = 0 ; i < 10 ; i++ ) {
for ( int j = 1 ; j <= r[ i] [ 0 ] ; j++ ) {
A[ k++ ] = r[ i] [ j] ;
}
}
}
private int getValueAt ( int value, int t) {
for ( int i = 0 ; i < t; i++ ) {
value /= 10 ;
}
return value % 10 ;
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new RadixSort ( ) . radixSort ( new int [ ] {
54 , 35 , 48 , 36 , 27 , 12 , 44 , 44 , 8 , 14 , 26 , 17 , 28 } , 13 ) ) ) ;
}
}
class ScaleSort {
public int [ ] sortElement ( int [ ] A, int n, int k) {
buildHeap ( A, k) ;
int [ ] ret = new int [ n] ;
int cnt = 0 ;
for ( int i = k; i < n; i++ ) {
ret[ cnt++ ] = A[ 0 ] ; A[ 0 ] = A[ i] ;
adjustDownToUp ( A, 0 , k) ;
}
for ( int i = k- 1 ; i > 0 ; i-- ) {
ret[ cnt++ ] = A[ 0 ] ;
A[ 0 ] = A[ i] ;
adjustDownToUp ( A, 0 , i) ;
}
ret[ cnt++ ] = A[ 0 ] ;
return ret;
}
private void buildHeap ( int [ ] A, int k) {
for ( int i = ( k- 2 ) / 2 ; i >= 0 ; i-- ) {
adjustDownToUp ( A, i, k) ;
}
}
private void adjustDownToUp ( int [ ] A, int root, int k) {
int temp = A[ root] ;
for ( int i = 2 * root + 1 ; i < k; i = 2 * i + 1 ) {
if ( i+ 1 < k && A[ i] > A[ i+ 1 ] ) {
i++ ;
}
if ( temp < A[ i] ) {
break ;
} else {
A[ root] = A[ i] ;
root = i;
}
}
A[ root] = temp;
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new ScaleSort ( ) . sortElement ( new int [ ] {
3 , 5 , 4 , 1 , 2 , 8 , 7 , 6 } , 8 , 5 ) ) ) ;
}
}
class Checker {
public boolean checkDuplicate ( int [ ] a, int n) {
buildHeap ( a) ;
for ( int i = a. length - 1 ; i >= 0 ; i-- ) {
int t = a[ 0 ] ;
a[ 0 ] = a[ i] ;
a[ i] = t;
adjustDownToUp ( a, 0 , i) ;
}
for ( int i = 1 ; i < n; i++ ) {
if ( a[ i] == a[ i- 1 ] ) {
return true ;
}
}
return false ;
}
private void buildHeap ( int [ ] a) {
for ( int i = ( a. length- 2 ) / 2 ; i >= 0 ; i-- ) {
adjustDownToUp ( a, i, a. length) ;
}
}
private void adjustDownToUp ( int [ ] a, int root, int length) {
int t = a[ root] ;
for ( int i = root * 2 + 1 ; i < length; i = 2 * i + 1 ) {
if ( i + 1 < length && a[ i] < a[ i+ 1 ] ) {
i++ ;
}
if ( a[ i] <= t) {
break ;
}
a[ root] = a[ i] ;
root = i;
}
a[ root] = t;
}
public static void main ( String[ ] args) {
System. out. println ( ( new Checker ( ) . checkDuplicate ( new int [ ] {
1 , 2 , 3 , 4 , 5 , 5 , 6 } , 7 ) ) ) ;
}
}
class Merge {
public int [ ] mergeAB ( int [ ] A, int [ ] B, int n, int m) {
int i = n- 1 , j = m - 1 , k = n+ m- 1 ;
while ( j >= 0 ) {
if ( i >= 0 && A[ i] > B[ j] ) {
A[ k-- ] = A[ i-- ] ;
} else {
A[ k-- ] = B[ j-- ] ;
}
}
return A;
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new Merge ( ) . mergeAB ( new int [ ] {
2 , 4 , 6 , 0 , 0 , 0 } , new int [ ] {
1 , 3 , 5 } , 3 , 3 ) ) ) ;
}
}
class ThreeColor {
public int [ ] sortThreeColor ( int [ ] A, int n) {
int i = 0 , j = 0 , k = n- 1 ;
while ( i <= k) {
if ( A[ i] == 0 ) {
int t = A[ j] ; A[ j] = A[ i] ; A[ i] = t;
i++ ; j++ ;
}
else if ( A[ i] == 2 ) {
int t = A[ k] ; A[ k] = A[ i] ; A[ i] = t;
k-- ;
} else {
i++ ;
}
}
return A;
}
public static void main ( String[ ] args) {
System. out. println ( Arrays. toString ( new ThreeColor ( ) . sortThreeColor ( new int [ ] {
1 , 2 , 0 , 2 } , 4 ) ) ) ;
}
}
class Finder {
public boolean findX ( int [ ] [ ] mat, int n, int m, int x) {
int i = 0 , j = m - 1 ;
while ( i >= 0 && j >= 0 ) {
if ( mat[ i] [ j] > x) {
j-- ;
}
else if ( mat[ i] [ j] < x) {
i++ ;
}
else return true ;
}
return false ;
}
public static void main ( String[ ] args) {
int [ ] [ ] a = new int [ ] [ ] {
{
109 , 204 , 260 , 270 } , {
452 , 602 , 671 , 917 } , {
1106 , 1343 , 1467 , 1585 } , {
1627 , 1866 , 1948 , 1980 } , {
2108 , 2164 , 2295 , 2577 } , {
2681 , 2749 , 2915 , 3026 } , {
3187 , 3250 , 3465 , 3518 } , {
3562 , 3773 , 3966 , 4101 } } ;
for ( int i = 0 ; i < a. length; i++ ) {
System. out. println ( Arrays. toString ( a[ i] ) ) ;
}
System. out. println ( new Finder ( ) . findX ( a, 8 , 4 , 2108 ) ) ;
}
}
class Subsequence {
public int shortestSubsequence ( int [ ] A, int n) {
int max= 0 , min = n- 1 , maxRight = 0 , minLeft = 0 ;
for ( int i = 1 ; i < n; i++ ) {
if ( A[ i] > A[ max] ) {
max = i;
}
if ( A[ i] < A[ max] ) {
maxRight = i;
}
}
for ( int i = n- 2 ; i >= 0 ; i-- ) {
if ( A[ i] < A[ min] ) {
min = i;
}
if ( A[ i] > A[ min] ) {
minLeft = i;
}
}
if ( maxRight == 0 && minLeft == 0 ) return 0 ;
return maxRight - minLeft + 1 ;
}
public static void main ( String[ ] args) {
System. out. println ( new Subsequence ( ) . shortestSubsequence ( new int [ ] {
1 , 4 , 6 , 5 , 9 , 10 } , 6 ) ) ;
}
}
class Gap {
static class ZJ {
int min = - 1 , max = - 1 ;
public ZJ ( int min, int max) {
this . max = max;
this . min = min;
}
@Override
public String toString ( ) {
return "ZJ{" +
"min=" + min +
", max=" + max +
'}' ;
}
}
public int maxGap ( int [ ] A, int n) {
int max = A[ 0 ] , min = A[ 0 ] ;
for ( int i = 0 ; i < n; i++ ) {
max = Math. max ( max, A[ i] ) ;
min = Math. min ( min, A[ i] ) ;
}
ZJ[ ] b = new ZJ [ n+ 1 ] ;
b[ n] = new ZJ ( max, max) ;
double len = ( max- min) * 1.0 / n;
for ( int i = 0 ; i < n; i++ ) {
double t = ( A[ i] - min) / len;
int pos= ( int ) t;
if ( b[ pos] == null) {
b[ pos] = new ZJ ( A[ i] , A[ i] ) ;
} else {
b[ pos] . min = Math. min ( b[ pos] . min, A[ i] ) ;
b[ pos] . max = Math. max ( b[ pos] . max, A[ i] ) ;
}
}
int dif = 0 ;
int last = - 1 ;
for ( int i = 0 ; i <= n; i++ ) {
if ( b[ i] != null) {
if ( last!= - 1 ) {
dif = Math. max ( b[ i] . min - last, dif) ;
}
last = b[ i] . max;
}
}
return dif;
}
public static void main ( String[ ] args) {
System. out. println ( new Gap