排序算法
冒泡排序
void BubbleSort ( int * start, int * stop) {
for ( int i= 0 ; i<= stop- start; i++ ) {
for ( int j= 0 ; j< stop- start- i- 1 ; j++ ) {
if ( start[ j] >= start[ j + 1 ] ) {
int temp= start[ j] ;
start[ j] = start[ j + 1 ] ;
start[ j+ 1 ] = temp;
}
}
}
return ;
}
时间复杂度:O(n²)
空间复杂度:O(1)
稳定
选择排序
void SelectSort ( int * start, int * stop) {
int i, j, index, n= stop- start;
for ( i= 0 ; i<= n; i++ ) {
index = i;
for ( j= i+ 1 ; j< n; j++ ) if ( start[ j] < start[ index] ) index = j;
swap ( start[ i] , start[ index] ) ;
}
return ;
}
时间复杂度:O(n²)
空间复杂度:O(1)
不稳定
插入排序
void InsertSort ( int * start, int * stop) {
for ( int i= 0 ; i<= stop- start; i++ ) {
int end= i;
int x= start[ end + 1 ] ;
while ( end>= 0 ) {
if ( start[ end] > x) {
start[ end+ 1 ] = start[ end] ;
start-- ;
}
else {
break ;
}
}
start[ end+ 1 ] = x;
}
return ;
}
时间复杂度:O(n²)
空间复杂度:O(1)
稳定
希尔排序
void ShellSort ( int * start, int * stop) {
int gap= stop- start;
while ( gap> 1 ) {
gap= gap/ 3 + 1 ;
for ( int i= 0 ; i< stop- start- gap; i++ ) {
int end= i;
int x= start[ end + gap] ;
while ( end>= 0 ) {
if ( start[ end] > x) {
start[ end+ gap] = start[ end] ;
end-= gap;
}
else break ;
}
start[ end + gap] = x;
}
}
return ;
}
时间复杂度:O(n^1.3)
空间复杂度:O(1)
不稳定
堆排序
void HeapSort ( int * start, int * stop) {
priority_queue< int , vector< int > , greater< int > > pq;
for ( int i= 0 ; i<= stop- start; i++ ) {
pq. push ( start[ i] ) ;
}
int cnt= 0 ;
while ( ! pq. empty ( ) ) {
start[ cnt++ ] = pq. top ( ) ;
pq. pop ( ) ;
}
}
时间复杂度:O(n logn)
空间复杂度:O(n)
不稳定
快速排序
void QuickSort ( int * start, int * stop) {
int mid, low= 0 , hight= stop- start;
if ( low< hight) {
int i= low, j= hight, pivot= start[ low] ;
while ( i< j) {
while ( i< j&& start[ j] > pivot) {
j-- ;
}
if ( i< j) {
swap ( start[ i++ ] , start[ j] ) ;
}
while ( i< j&& start[ i] <= pivot) {
i++ ;
}
if ( i< j) {
swap ( start[ i] , start[ j-- ] ) ;
}
}
mid= i;
QuickSort ( start, mid+ start- 1 ) ;
QuickSort ( mid+ start+ 1 , stop) ;
}
}
时间复杂度:O(n logn)
空间复杂度:O(n logn)
不稳定
归并排序
void MergeSort ( int * start, int * stop) {
int left= 0 , right= stop- start;
if ( left< right) {
int mid= left+ ( right - left) / 2 ;
MergeSort ( left+ start, mid+ start) ;
MergeSort ( mid+ 1 + start, right+ start) ;
int L1= left, R1= mid, L2= mid+ 1 , R2= right;
int i= L1, j= L2;
int temp[ 1000001 ] , index= 0 ;
while ( i<= R1&& j<= R2) {
if ( start[ i] <= start[ j] )
temp[ index++ ] = start[ i++ ] ;
else
temp[ index++ ] = start[ j++ ] ;
}
while ( i<= R1) temp[ index++ ] = start[ i++ ] ;
while ( j<= R2) temp[ index++ ] = start[ j++ ] ;
for ( i = 0 ; i< index; i++ ) {
start[ L1+ i] = temp[ i] ;
}
}
}
时间复杂度:O(n logn)
空间复杂度:O(n)
稳定
计数排序
void CountSort ( int * start, int * stop) {
int n= stop- start;
int max= start[ 0 ] ;
int min= start[ 0 ] ;
for ( int i= 0 ; i<= n; i++ ) {
if ( start[ i] > max) {
max= start[ i] ;
}
if ( start[ i] < min)
{
min= start[ i] ;
}
}
int range= max- min+ 1 ;
int * count= ( int * ) malloc ( sizeof ( int ) * range) ;
assert ( count) ;
memset ( count, 0 , sizeof ( int ) * range) ;
for ( int i= 0 ; i<= n; i++ ) {
count[ start[ i] - min] ++ ;
}
int j= 0 ;
for ( int i= 0 ; i< range; i++ ) {
while ( count[ i] -- ) {
start[ j++ ] = i+ min;
}
}
return ;
}
时间复杂度:O(n+k)
空间复杂度:O(n+k)
稳定
基数排序
void RadixSort ( int * start, int * stop) {
int n= stop- start;
int d= 1 ;
int p= 10 ;
for ( int i = 0 ; i < n; ++ i) {
while ( start[ i] >= p) {
p*= 10 ;
++ d;
}
}
int digits= d;
list< int > lists[ stop- start+ 10 ] ;
int j, k, factor;
for ( d= 1 , factor= 1 ; d<= digits; factor*= 10 , d++ ) {
for ( j = 0 ; j < n; j++ ) {
lists[ ( start[ j] / factor) % 10 ] . push_back ( start[ j] ) ;
}
for ( j= k= 0 ; j< 10 ; j++ ) {
while ( ! lists[ j] . empty ( ) ) {
start[ k++ ] = lists[ j] . front ( ) ;
lists[ j] . pop_front ( ) ;
}
}
}
}
时间复杂度:O(n+k)
空间复杂度:O(n+k)
稳定