冒泡排序
#include <stdio.h>
typedef int ElementType;
void BubbleSort ( ElementType A[ ] , int N)
{
int i, j, Tmp;
for ( i = 0 ; i < N - 1 ; i++ )
{
for ( j = 0 ; j < N - 1 - i; j++ )
{
if ( A[ j] > A[ j + 1 ] )
{
Tmp = A[ j] ;
A[ j] = A[ j + 1 ] ;
A[ j + 1 ] = Tmp;
}
}
}
}
选择排序
#include <stdio.h>
typedef int ElementType;
void Swap ( ElementType * a, ElementType * b)
{
ElementType Tmp;
Tmp = * a;
* a = * b;
* b = Tmp;
}
void CelecteSort ( ElementType A[ ] , int N)
{
int i, j;
for ( i = 0 ; i < N; i++ )
{
int Min = i;
for ( j = i + 1 ; j < N; j++ )
{
if ( A[ j] < A[ Min] )
Min = j;
}
Swap ( & A[ Min] , & A[ i] ) ;
}
}
插入排序
#include <stdio.h>
typedef int ElementType;
void InsertionSort ( ElementType A[ ] , int N)
{
int j, P;
ElementType Tmp;
for ( P = 1 ; P < N; P++ )
{
Tmp = A[ P] ;
for ( j = P; j > 0 && A[ j - 1 ] > Tmp; j-- )
A[ j] = A[ j - 1 ] ;
A[ j] = Tmp;
}
}
堆排序
#include <stdio.h>
#include <stdlib.h>
#define LeftChild(i)(2 * (i) + 1)
typedef int ElementType;
void Swap ( ElementType * a, ElementType * b)
{
ElementType Tmp;
Tmp = * a;
* a = * b;
* b = Tmp;
}
void PercDown ( ElementType A[ ] , int i, int N)
{
int Child;
ElementType Tmp;
for ( Tmp = A[ i] ; LeftChild ( i) < N; i = Child)
{
Child = LeftChild ( i) ;
if ( Child != N - 1 && A[ Child + 1 ] > A[ Child] )
Child++ ;
if ( Tmp < A[ Child] )
A[ i] = A[ Child] ;
else
break ;
}
A[ i] = Tmp;
}
void HeapSort ( ElementType A[ ] , int N)
{
int i;
ElementType Tmp;
for ( i = N / 2 ; i >= 0 ; i-- )
PercDown ( A, i, N) ;
for ( i = N - 1 ; i > 0 ; i-- )
{
Swap ( & A[ 0 ] , & A[ i] ) ;
PercDown ( A, 0 , i) ;
}
}
归并排序
#include <stdio.h>
#include <stdlib.h>
typedef int ElementType;
void Merge ( ElementType A[ ] , ElementType TmpArray[ ] , int Lpos, int Rpos, int RightEnd)
{
int i, LeftEnd, NumElements, TmpPos;
LeftEnd = Rpos - 1 ;
TmpPos = Lpos;
NumElements = RightEnd - Lpos + 1 ;
while ( Lpos <= LeftEnd && Rpos <= RightEnd)
{
if ( A[ Lpos] <= A[ Rpos] )
TmpArray[ TmpPos++ ] = A[ Lpos++ ] ;
else
TmpArray[ TmpPos++ ] = A[ Rpos++ ] ;
}
while ( Lpos <= LeftEnd)
TmpArray[ TmpPos++ ] = A[ Lpos++ ] ;
while ( Rpos <= RightEnd)
TmpArray[ TmpPos++ ] = A[ Rpos++ ] ;
for ( i = 0 ; i < NumElements; i++ , RightEnd-- )
A[ RightEnd] = TmpArray[ RightEnd] ;
}
void MSort_Recursion ( ElementType A[ ] , ElementType TmpArray[ ] , int Left, int Right)
{
int Center;
if ( Left < Right)
{
Center = ( Left + Right) / 2 ;
MSort_Recursion ( A, TmpArray, Left, Center) ;
MSort_Recursion ( A, TmpArray, Center + 1 , Right) ;
Merge ( A, TmpArray, Left, Center + 1 , Right) ;
}
}
void MergeSort_Recursion ( ElementType A[ ] , int N)
{
ElementType * TmpArray;
TmpArray = ( ElementType* ) malloc ( sizeof ( ElementType) * N) ;
if ( TmpArray != NULL )
{
MSort_Recursion ( A, TmpArray, 0 , N - 1 ) ;
free ( TmpArray) ;
}
else printf ( "空间不足" ) ;
}
void Merge_NonRecursive ( ElementType A[ ] , ElementType TmpArray[ ] , int N, int Length)
{
int i, j;
for ( i = 0 ; i <= N - 2 * Length; i + = 2 * Length)
Merge ( A, TmpArray, i, i + Length, i + 2 * Length - 1 ) ;
if ( i + Length < N)
Merge ( A, TmpArray, i, i + Length, N - 1 ) ;
else
for ( j = i; j < N; j++ )
TmpArray[ j] = A[ j] ;
}
void MergeSort_NonRecursive ( ElementType A[ ] , int N)
{
int Length;
ElementType * TmpArray;
Length = 1 ;
TmpArray = ( ElementType* ) malloc ( N * sizeof ( ElementType) ) ;
if ( TmpArray != NULL ) {
while ( Length < N) {
Merge_NonRecursive ( A, TmpArray, N, Length) ;
Length * = 2 ;
Merge_NonRecursive ( TmpArray, A, N, Length) ;
Length * = 2 ;
}
free ( TmpArray) ;
}
else printf ( "空间不足" ) ;
}
希尔排序
#include <stdio.h>
#include <math.h>
typedef int ElementType;
void ShellSort0 ( ElementType A[ ] , int N)
{
int i, j, Increment;
ElementType Tmp;
for ( Increment = N / 2 ; Increment > 0 ; Increment / = 2 )
{
for ( i = Increment; i < N; i++ )
{
Tmp = A[ i] ;
for ( j = i; j >= Increment; j - = Increment)
if ( Tmp < A[ j - Increment] )
A[ j] = A[ j - Increment] ;
else
break ;
A[ j] = Tmp;
}
}
}
double log2 ( double input)
{
return log ( input) / log ( 2 ) ;
}
void ShellSort1 ( ElementType A[ ] , int N)
{
int i, j, k, Round, Increment;
ElementType Tmp;
for ( Round = ( int ) log2 ( N) ; Round > 0 ; Round-- )
{
Increment = ( int ) pow ( 2 , Round) - 1 ;
for ( i = Increment; i < N; i++ )
{
Tmp = A[ i] ;
for ( j = i; j >= Increment; j - = Increment)
if ( Tmp < A[ j - Increment] )
A[ j] = A[ j - Increment] ;
else
break ;
A[ j] = Tmp;
}
}
}
void ShellSort2 ( ElementType A[ ] , int N)
{
int i, j, k, Increment;
ElementType Tmp;
int Sedgewick[ ] = { 929 , 505 , 209 , 109 , 41 , 19 , 5 , 1 , 0 } ;
for ( k = 0 ; Sedgewick[ k] >= N; k++ )
;
for ( Increment = Sedgewick[ k] ; Increment > 0 ; Increment = Sedgewick[ ++ k] )
{
for ( i = Increment; i < N; i++ )
{
Tmp = A[ i] ;
for ( j = i; j >= Increment; j - = Increment)
if ( Tmp < A[ j - Increment] )
A[ j] = A[ j - Increment] ;
else
break ;
A[ j] = Tmp;
}
}
}
快速排序
#include <stdio.h>
#include <stdlib.h>
#define Cutoff 3
typedef int ElementType;
void Swap ( ElementType * a, ElementType * b)
{
ElementType Tmp;
Tmp = * a;
* a = * b;
* b = Tmp;
}
void InsertionSort ( ElementType A[ ] , int N)
{
int j, P;
ElementType Tmp;
for ( P = 1 ; P < N; P++ )
{
Tmp = A[ P] ;
for ( j = P; j > 0 && A[ j - 1 ] > Tmp; j-- )
A[ j] = A[ j - 1 ] ;
A[ j] = Tmp;
}
}
ElementType Median3 ( ElementType A[ ] , int Left, int Right)
{
int Center = ( Left + Right) / 2 ;
if ( A[ Left] > A[ Center] )
Swap ( & A[ Left] , & A[ Center] ) ;
if ( A[ Left] > A[ Right] )
Swap ( & A[ Left] , & A[ Right] ) ;
if ( A[ Center] > A[ Right] )
Swap ( & A[ Center] , & A[ Right] ) ;
Swap ( & A[ Center] , & A[ Right - 1 ] ) ;
return A[ Right - 1 ] ;
}
void QSort ( ElementType A[ ] , int Left, int Right)
{
int i, j;
ElementType Pivot;
if ( Right - Left >= Cutoff)
{
Pivot = Median3 ( A, Left, Right) ;
i = Left;
j = Right - 1 ;
for ( ; ; )
{
while ( A[ ++ i] < Pivot) { }
while ( A[ -- j] > Pivot) { }
if ( i < j)
Swap ( & A[ i] , & A[ j] ) ;
else
break ;
}
Swap ( & A[ i] , & A[ Right - 1 ] ) ;
QSort ( A, Left, i - 1 ) ;
QSort ( A, i + 1 , Right) ;
}
else
InsertionSort ( A + Left, Right - Left + 1 ) ;
}
void QuickSort ( ElementType A[ ] , int N)
{
QSort ( A, 0 , N - 1 ) ;
}
基数排序
#include <stdio.h>
#include <stdlib.h>
typedef int ElementType;
#define MaxDigit 4
#define Radix 10
typedef struct Node * PtrToNode;
struct Node {
int key;
PtrToNode next;
} ;
struct HeadNode {
PtrToNode head, tail;
} ;
typedef struct HeadNode Bucket[ Radix] ;
int GetDigit ( int X, int D )
{
int d, i;
for ( i= 1 ; i<= D; i++ ) {
d = X % Radix;
X / = Radix;
}
return d;
}
void LSDRadixSort ( ElementType A[ ] , int N )
{
int D, Di, i;
Bucket B;
PtrToNode tmp, p, List = NULL ;
for ( i= 0 ; i< Radix; i++ )
B[ i] . head = B[ i] . tail = NULL ;
for ( i= 0 ; i< N; i++ ) {
tmp = ( PtrToNode) malloc ( sizeof ( struct Node) ) ;
tmp- > key = A[ i] ;
tmp- > next = List;
List = tmp;
}
for ( D= 1 ; D<= MaxDigit; D++ ) {
p = List;
while ( p) {
Di = GetDigit ( p- > key, D) ;
tmp = p; p = p- > next;
tmp- > next = NULL ;
if ( B[ Di] . head == NULL )
B[ Di] . head = B[ Di] . tail = tmp;
else {
B[ Di] . tail- > next = tmp;
B[ Di] . tail = tmp;
}
}
List = NULL ;
for ( Di= Radix- 1 ; Di>= 0 ; Di-- ) {
if ( B[ Di] . head) {
B[ Di] . tail- > next = List;
List = B[ Di] . head;
B[ Di] . head = B[ Di] . tail = NULL ;
}
}
}
for ( i= 0 ; i< N; i++ ) {
tmp = List;
List = List- > next;
A[ i] = tmp- > key;
free ( tmp) ;
}
}
#define MaxDigit 4
#define Radix 10
typedef struct Node * PtrToNode;
struct Node{
int key;
PtrToNode next;
} ;
struct HeadNode {
PtrToNode head, tail;
} ;
typedef struct HeadNode Bucket[ Radix] ;
int GetDigit ( int X, int D )
{
int d, i;
for ( i= 1 ; i<= D; i++ ) {
d = X% Radix;
X / = Radix;
}
return d;
}
void MSD ( ElementType A[ ] , int L, int R, int D )
{
int Di, i, j;
Bucket B;
PtrToNode tmp, p, List = NULL ;
if ( D== 0 ) return ;
for ( i= 0 ; i< Radix; i++ )
B[ i] . head = B[ i] . tail = NULL ;
for ( i= L; i<= R; i++ ) {
tmp = ( PtrToNode) malloc ( sizeof ( struct Node) ) ;
tmp- > key = A[ i] ;
tmp- > next = List;
List = tmp;
}
p = List;
while ( p) {
Di = GetDigit ( p- > key, D) ;
tmp = p; p = p- > next;
if ( B[ Di] . head == NULL ) B[ Di] . tail = tmp;
tmp- > next = B[ Di] . head;
B[ Di] . head = tmp;
}
i = j = L;
for ( Di= 0 ; Di< Radix; Di++ ) {
if ( B[ Di] . head) {
p = B[ Di] . head;
while ( p) {
tmp = p;
p = p- > next;
A[ j++ ] = tmp- > key;
free ( tmp) ;
}
MSD ( A, i, j- 1 , D- 1 ) ;
i = j;
}
}
}
void MSDRadixSort ( ElementType A[ ] , int N )
{
MSD ( A, 0 , N- 1 , MaxDigit) ;
}