冒泡排序
稳定性: 稳定
最坏时间复杂度O(N^2)
最好时间复杂度O(N)
平均时间复杂度O(N^2)
void bubble_sort(int *a, int n)
{
for(int i = 0; i < n; ++i)
{
int flag = false;
for(int j = n - 2; j >= 0; --j)
{
if(a[j] > a[j + 1])
{
_swap(a[j], a[j+1]);
flag = true;
}
}
if(!flag)
break;
}
}
插入排序
稳定性: 稳定
平均时间复杂度O(N^2)
最坏时间复杂度O(N^2)
最好时间复杂度O(N)
void insert_sort(int *a, int n)
{
for(int i = 1; i < n; i++)
{
int j = i - 1;
int key = a[i];
while(j >= 0 && a[j] > key)
{
a[j + 1] = a[j];
--j;
}
a[j + 1] = key;
}
}
选择排序
稳定性: 不稳定
平均时间复杂度O(N^2)
最坏时间复杂度O(N^2)
最好时间复杂度O(N^2)
void select_sort(int *a, int n)
{
for(int i = 0; i < n; ++i)
{
int min = a[i];
int index = i;
for(int j = i + 1; j < n; j++)
{
if(a[j] < min)
{
min = a[j];
index = j;
}
}
if(index != i)
_swap(a[index], a[i]);
}
}
快速排序
稳定性: 不稳定
最差时间复杂度O(N^2)
最好时间复杂度O(NlogN)
平均时间复杂度O(NlogN)
void quick_sort(int *a, int l, int r)
{
if(l < r)
{
int i = l;
int j = r;
int x = a[i];
while(i < j)
{
while(i < j && a[j] >= x)
--j;
if(i < j)
a[i] = a[j];
while(i < j && a[i] <= x)
++i;
if(i < j)
a[j] = a[i];
}
a[i] = x;
quick_sort(a, l, i - 1);
quick_sort(a, i + 1, r);
}
}
希尔排序
稳定性: 不稳定
平均时间复杂度O(NlogN)
void shell_sort(int *a, int n)
{
for(int grap = n/2; grap > 0; grap /= 2)
{
for(int i = 0; i <= grap; ++i)
{
for(int j = i + grap; j < n; j += grap)
{
int temp = a[j];
int k = j - grap;
while(k >= 0 && a[k] > temp)
{
a[k + grap] = a[k];
k -= grap;
}
a[k + grap] = temp;
}
}
}
}
归并排序
稳定性: 稳定
平均时间复杂度O(NlogN)
最坏时间复杂度O(NlogN)
最好时间复杂度O(NlogN)
空间复杂度O(N)
void _merge(int *a, int left, int mid, int right)
{
int len = right - left + 1;
int *temp = new int[len];
int i = left;
int j = mid + 1;
int k = 0;
while(i <= mid && j <= right)
{
if(a[i] < a[j])
temp[k++] = a[i++];
else
temp[k++] = a[j++];
}
while(i <= mid)
{
temp[k++] = a[i++];
}
while(j <= right)
{
temp[k++] = a[j++];
}
for(k = 0; k < len; ++k)
a[k + left] = temp[k];
delete []temp;
}
void merge_sort(int *a, int left, int right)
{
if(left < right)
{
int mid = (left + right) / 2;
merge_sort(a, left, mid);
merge_sort(a, mid + 1, right);
_merge(a, left, mid, right);
}
}
堆排序
稳定性: 不稳定
平均时间复杂度O(NlogN)
最坏时间复杂度O(NlogN)
最好时间复杂度O(NlogN)
void adjust_heap(int *a, int holeIndex, int len)
{
int temp = a[holeIndex];
int child = 2 * holeIndex + 1;
while(child < len)
{
if(child + 1 < len && a[child] < a[child + 1])
child++;
if(a[child] > temp)
{
a[holeIndex] = a[child];
holeIndex = child;
child = 2 * holeIndex + 1;
}
else
break;
}
a[holeIndex] = temp;
}
void build_heap(int *a, int len)
{
for(int i = (len - 1) / 2; i >= 0; --i)
adjust_heap(a, i, len);
}
void heap_sort(int *a, int len)
{
build_heap(a, len);
for(int i = len - 1 ; i >= 0; --i)
{
_swap(a[0], a[i]);
adjust_heap(a, 0, i);
}
}