常用算法总结(包括代码,时间复杂度)
(本文中为从小到大排序)
1、冒泡排序
最常用的排序算法了,从第1个数开始,和下一个数进行比较,假如下一个数小,则交换这两个数的位置,第一趟排序得到数组的最大值,第二趟排序得到次最大值,依次列推,若一趟比较中没有交换,则数组已经正序排列。排序结束。
最好的情况:正序排列,时间复杂度O(n);
最差的情况:逆序排列,时间复杂度O(nn);
平均时间复杂度:O(nn);
代码如下:
void bubble(int array[],int length)//every time it gets a biggest number
{
for (int i = 0; i < length-1; i++)
{
bool flag = false;
for (int j = 0; j < length - i-1; j++)
{
if (array[j]>array[j + 1])
{
swap(array[j], array[j + 1]);
flag = true;
}
}
if (!flag) break;//假如某次排序没有交换,则说明已经正序
}
return;
}
2、选择排序
第一遍从n个数中选出最小的数,记录他的位置,和第一个数交换;然后再n-1个数中选出最小的数,记录位置,和第二个数交换。以此类推,直到最后一个数。
最好的情况,最坏的情况,平均情况:O(n*n);
void select(int array[], int length)
{
for (int i = 0; i < length-1; i++)
{
int min = i;
int j = i+1;
while (j < length)
{
if (array[j] < array[min])
{
min = j;
}
j++;
}
if (min != i) swap(array[i], array[min]);
}
return;
}
3直接插入排序
直接插入排序就是从第二个数开始,往前插入到合适的位置(如果小于某个位置的数,继续向前,直到大于或等于)。
最好的情况:正序排列O(n);
最坏的情况:逆序排列O(nn);
平均情况:O(nn);
代码如下:
void insert(int array[], int length)//every time it gets a smallest number
{
for (int i = 0; i < length-1; i++)
{
int j = i;
int temp = array[i];
while (j >= 0&&array[j+1]<array[j])
{
swap(array[j], array[j + 1]);
j--;
}
}
}
4、快速排序
快排首先需要在数组中随机选一个数,然后把数组分别排列到这个数的两边,大于它的在右边,小于它的在左边,然后再在它的左右两边数组中分别选一个数,继续上面的操作,直到全部数组有序。
最好的情况:正序排列O(nlogn);
最坏的情况:逆序排列O(nn);
平均情况:O(nlogn);
代码如下:
int oncesort(int array[], int start, int end)//choose the number at end and sort the two groups of numbers
{
if (start > end||start<0) return -1;
int small = start - 1;
for (int index = start; index < end; index++)
{
if (array[index] < array[end])
{
small++;
if (small != index)
swap(array[index], array[small]);
}
}
small++;
swap(array[small], array[end]);
return small;
}
void quick(int array[], int start,int end)
{
if (start == end) return;
int index = oncesort(array,start,end);
if (index > start) quick(array, start, index-1);
if (index < end) quick(array, index + 1, end);
return;
}
5、希尔排序
也是一种选择排序,但是是分区域来进行排序,先选择一个增量,对对应的增量进行排序,然后逐步减小增量,直到最后增量为1时,几乎已经是排好序的序列了。
最好的情况:O(nlogn);
最坏的情况:O(nlogn);
平均情况:O(n*logn);
代码如下:
void herl(int array[], int length)
{
if (length < 0) return;
for (int add = length / 2; add > 0; add = add / 2)
{
for (int i = 0; i + add < length; i++)
{
if (array[i]>array[i + add])
swap(array[i], array[i + add]);
}
}
return;
}
6、归并排序
归并排序和快排类似,不过归并排序是把数组直接分成前后两个部分进行排序,然后前后两个数组再继续分成两个数组,直到有序。每次排好的部分按顺序放进一个新的数组中,最后把这个数组一一赋值出传递给原数组得到有序数组。
最好的情况:O(nlogn);
最坏的情况:O(nlogn);
平均情况:O(n*logn);
代码如下:
void mergetwo(int array[], int start, int mid,int end, int *temp)
{
int k = start;
int i = start, j = mid + 1;
while ( i <= mid&&j <= end)
{
if (array[i] <= array[j])
{
temp[k++] = array[i++];
}
else
temp[k++] = array[j++];
}
while (i <= mid) temp[k++] = array[i++];
while (j <= end) temp[k++] = array[j++];
for (int i = start; i <= end; i++)
{
array[i] = temp[i];
}
}
void mergecore(int array[], int start, int end, int *temp)
{
if (start >= end) return;
int mid = (end + start) / 2;
mergecore(array, start, mid, temp);
mergecore(array, mid + 1, end, temp);
mergetwo(array, start, mid, end, temp);
return;
}
void merge(int array[], int length)
{
if (length<1) return;
int *temp = new int[length]();
int start = 0;
int end = length - 1;
mergecore(array, start, end, temp);
show(array, length);
delete[]temp;
}
7、堆排序
堆排序首先需要把数组建立成一个最大堆,然后交换堆顶和堆的最后一个数,然后去掉最后一个数,继续调整数组为最大堆,再交换堆顶和堆的最后一个数,直到数组有序。
最好的情况:O(nlogn);
最坏的情况:O(nlogn);
平均情况:O(n*logn);
代码如下:
void maxheap(int array[], int start, int end)
{
int dad = start;
int son = 2 * dad + 1;
while (son <= end)
{
if (son + 1 <= end&&array[son] < array[son + 1])
son++;
if (array[dad] > array[son])
return;
else
swap(array[son], array[dad]);
dad = son;
son = dad * 2 + 1;
}
}
void heap(int array[], int length)
{
for (int i = length / 2 - 1; i >= 0; i--)
maxheap(array, i, length - 1);
for (int i = length - 1; i > 0; i--)
{
swap(array[0], array[i]);
maxheap(array, 0, i-1);
}
return;
}