直接插入排序
public void sort ( int [ ] nums) {
for ( int i = 1 ; i < nums. length; i++ ) {
int tmp = nums[ i] ;
int j;
for ( j = i; j>= 0 && tmp < nums[ j- 1 ] ; j-- ) {
nums[ j] = nums[ j- 1 ] ;
}
num[ j] = tmp;
}
}
平均时间复杂度 最好情况 最坏情况 空间复杂度 稳定性 O(n²) O(n²) O(n²) O(1) 稳定
希尔排序
希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。已知的最好步长序列是由Sedgewick提出的(1, 5, 19, 41, 109,…)。
这项研究也表明“比较在希尔排序中是最主要的操作,而不是交换。”用这样步长序列的希尔排序比插入排序和堆排序都要快,甚至在小数组中比快速排序还快,但是在涉及大量数据时希尔排序还是比快速排序慢。
public void sort ( int [ ] a)
{
int h = 1 ;
int len = a. length;
while ( h < len / 3 ) h = h * 3 + 1 ;
for ( ; h>= 1 ; h/= 3 )
{
for ( int i = 0 ; i < len- h; i+= h)
{
for ( int j = i+ h; j > 0 ; j-= h)
{
if ( a[ j] < a[ j- h] )
{
int tmp = a[ j] ;
a[ j] = a[ j- h] ;
a[ j- h] = tmp;
}
}
}
}
}
平均时间复杂度 最好情况 最坏情况 空间复杂度 稳定性 O(nlog2 n) O(nlog2 n) O(nlog2 n) O(1) 不稳定
选择排序
public void sort ( int [ ] a)
{
for ( int i = 0 ; i < a. length; i++ )
{
int min = i;
for ( int j = i+ 1 ; j < a. length; j++ )
{
if ( a[ min] > a[ j] )
{
min = j;
}
}
if ( min!= i)
{
int tmp = a[ min] ;
a[ min] = a[ i] ;
a[ i] = tmp;
}
}
}
平均时间复杂度 最好情况 最坏情况 空间复杂度 稳定性 O(n²) O(n²) O(n²) O(1) 不稳定
堆排序
public void heapsort ( int [ ] a, int n) {
for ( int i = ( n- 2 ) / 2 ; i>= 0 ; i-- ) {
maxheap ( a, i, n) ;
}
int end = n- 1 ;
while ( end > 0 ) {
swap ( a, 0 , end) ;
maxheap ( a, 0 , end) ;
end-- ;
}
}
void maxheap ( int [ ] a, int root, int len) {
int parent = root;
int child = parent * 2 + 1 ;
while ( child < len) {
if ( ( child+ 1 ) < len&& a[ child+ 1 ] < a[ child] ) {
child++ ;
}
if ( a[ child] < a[ parent] ) {
swap ( a, child, parent) ;
parent = child;
child = parent * 2 + 1 ;
}
else break ;
}
}
void swap ( int [ ] a, int i , int j) {
int tmp = a[ i] ;
a[ i] = a[ j] ;
a[ j] = tmp;
}
public void heapsort ( int [ ] a, int n) {
for ( int i = ( n- 2 ) / 2 ; i>= 0 ; i-- ) {
maxheap ( a, i, n) ;
}
int end = n- 1 ;
while ( end > 0 ) {
swap ( a, 0 , end) ;
maxheap ( a, 0 , end) ;
end-- ;
}
}
void maxheap ( int [ ] a, int root, int len) {
int parent = root;
int child = parent * 2 + 1 ;
while ( child < len) {
if ( ( child+ 1 ) < len&& a[ child+ 1 ] > a[ child] ) {
child++ ;
}
if ( a[ child] > a[ parent] ) {
swap ( a, child, parent) ;
parent = child;
child = parent * 2 + 1 ;
}
else break ;
}
}
void swap ( int [ ] a, int i , int j) {
int tmp = a[ i] ;
a[ i] = a[ j] ;
a[ j] = tmp;
}
平均时间复杂度 最好情况 最坏情况 空间复杂度 稳定性 𝑂(𝑛log2𝑛) 𝑂(𝑛log2𝑛) 𝑂(𝑛log2𝑛) O(1) 不稳定
冒泡排序
public static void sort ( int [ ] a)
{
for ( int i = 0 ; i < a. length - 1 ; i++ )
{
for ( int j = 0 ; j < a. length - 1 - i; j++ )
{
if ( a[ j] > a[ j+ 1 ] )
{
int tmp = a[ j] ;
a[ j] = a[ j+ 1 ] ;
a[ j+ 1 ] = tmp;
}
}
}
}
平均时间复杂度 最好情况 最坏情况 空间复杂度 稳定性 O(n²) O(n) O(n²) O(1) 稳定
快速排序
public static void sort ( int [ ] a, int low, int high)
{
if ( low >= high)
{
return ;
}
int left = low;
int right = high;
int pivot = a[ low] ;
while ( left < right)
{
while ( left < right && a[ right] >= pivot)
right-- ;
while ( left < right && a[ left] <= pivot)
left++ ;
if ( left< right) {
int tmp = a[ left] ;
a[ left] = a[ right] ;
a[ right] = tmp;
}
}
a[ low] = a[ left] ;
a[ left] = pivot;
sort ( a, low, left- 1 ) ;
sort ( a, left+ 1 , high) ;
}
平均时间复杂度 最好情况 最坏情况 空间复杂度 稳定性 O(nlogn) O(nlogn) O(n²) O(nlogn) 不稳定
快排改进(三向快速排序)
public static void sort ( int [ ] a, int lo, int hi)
{
if ( lo >= hi)
{
return ;
}
int v = a[ lo] , lt = lo, i = lo + 1 , gt = hi;
while ( i <= gt)
{
if ( a[ i] < v)
{
swap ( a, i++ , lt++ )
}
else if ( a[ i] > v)
{
swap ( a, i, gt-- ) ;
} else
{
i++ ;
}
}
sort ( a, lo, lt - 1 ) ;
sort ( a, gt + 1 , hi) ;
}
private static void swap ( int [ ] a, int i, int j)
{
int t = a[ i] ;
a[ i] = a[ j] ;
a[ j] = t;
}
平均时间复杂度 最好情况 最坏情况 空间复杂度 稳定性 O(nlogn) O(nlogn) O(n²) O(1) 不稳定
归并排序
public static sort ( int [ ] a, int low, int high) {
int mid = ( low + high) / 2 ;
if ( low < high) {
sort ( a, low, mid) ;
sort ( a, mid + 1 , high) ;
merge ( a, low, mid, high) ;
}
return a;
}
public static void merge ( int [ ] a, int low, int mid, int high)
{
int [ ] tmp = new int [ high - low + 1 ] ;
int i = low;
int j = mid + 1 ;
int k = 0 ;
while ( i <= mid && j <= high) {
if ( a[ i] < a[ j] ) {
tmp[ k++ ] = a[ i++ ] ;
} else {
tmp[ k++ ] = a[ j++ ] ;
}
}
while ( i <= mid) {
tmp[ k++ ] = a[ i++ ] ;
}
while ( j <= high) {
tmp[ k++ ] = a[ j++ ] ;
}
for ( int x = 0 ; x < tmp. length; x++ )
{
a[ x+ low] = tmp[ x] ;
}
}
平均时间复杂度 最好情况 最坏情况 空间复杂度 稳定性 𝑂(𝑛log2𝑛) 𝑂(𝑛log2𝑛) 𝑂(𝑛log2𝑛) O(n) 稳定
基数排序
private static void sort ( int [ ] a)
{
int max = 0 ;
for ( int i = 0 ; i < a. length; i++ )
{
if ( max < a[ i] )
max = a[ i] ;
}
int maxDigit = 1 ;
while ( max / 10 > 0 ) {
maxDigit++ ;
max /= 10 ;
}
int [ ] [ ] buckets = new int [ 10 ] [ a. length] ;
int base = 10 ;
for ( int i = 0 ; i < maxDigit; i++ )
{
int [ ] bktLen = new int [ 10 ] ;
for ( int j = 0 ; j < a. length; j++ )
{
int whichBucket = ( a[ j] % base) / ( base/ 10 ) ;
buckets[ whichBucket] [ bktLen[ whichBucket] ] = arr[ j] ;
bktLen[ whichBucket] ++ ;
}
int k = 0 ;
for ( int b = 0 ; b < buckets. length; b++ ) {
for ( int p = 0 ; p < bktLen[ b] ; p++ ) {
a[ k++ ] = buckets[ b] [ p] ;
}
}
base *= 10 ;
}
}
平均时间复杂度 最好情况 最坏情况 空间复杂度 稳定性 O(d*(n+r)) O(d*(n+r)) O(d*(n+r)) O(n+r) 稳定