激励我写博文有很大的原因是,在校电面的时候,被问到了很多基础算法问题。当时瞬间懵哔了。痛定思痛。决定好好复习下常用的基础算法。
一).常见的排序算法。
1).简单选择排序。
基本思想:每一趟在后面n-1个待排的数据中选出一个最小(大)的数据作为有序序列的第i个元素。之后依次循环遍历。
简单选择排序是稳定排序,平均时间复杂度为O(n²),最坏时间复杂度为O(n²),空间复杂度O(1);
static void swap(int a[], int i, int j)
{
int tmp = 0;
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
void SelectSort(int a[], int n)
{
if (!a && n < 0) return;
int i = 0, j = 0;
int k = -1;
for (; i < n; i++)
{
k = i;
for (j = i + 1; j < n; j++)
{
if (a[j] < a[k])
k = j;
}
swap(a, i, k);
}
}
2).冒泡排序算法
基本思想:将序列中第一个元素与第二个元素进行比较,若为逆序(升序)a[2] > a[1](a[2] < a[1])则交换,然后再比较第二个元素与第三个元素,依次进行,每趟选出一个最大(小)值。冒泡排序已选择排序的区别:选择排序是每趟与最小(大)值交换,冒泡排序是每趟移动相邻的位置。
小技巧: 可以在冒泡排序中定义一个变量,用于表示冒泡排序受否排列好了。如果要有一个已经基本有序的序列,则可以减少循环次数。
冒泡排序属于交换排序,是稳定排序。平均时间复杂度为O(n²),最坏时间复杂度为O(n²),空间复杂度O(1);
void BubbleSort(int a[], int len)
{
if (!a && len < 0) return;
int i = 0, j = 0;
int exchange = 1;
for (; (i < len - 1) && exchange; i++)
{
exchange = 0;
for (j = 0; j < len - 1 - i; j++)
{
if (a[j + 1] < a[j])
{
swap(a, j, j + 1);
exchange = 1;
}
}
}
}
3).快速排序
基本思想:通过一趟排序将序列分割成独立的两部分,其中一部分的所有数据要比另一部分的所有数据小。基准数据排在两个部分的中间。依次快排两个模块。现在这个算法分为两个过程,一个是根据基准数据划分模块,一个是递归的划分模块及排列数据。
快速排序也属于交换排序,不稳定排序。平均时间复杂度为O(nlog2n), 最坏时间复杂度为O(n²),空间复杂度为O(nlog2n);
int partion(int a[], int low, int high)
{
if (!a) return -1;
int privot = a[low];
while (low < high)
{
while ((low < high) && (a[high] > privot))
high--;
swap(a, low, high);
while ((low < high) && (a[low] <= privot))
low++;
swap(a, low, high);
}
return low;
}
void Qsort(int a[], int low, int high)
{
int privot = 0;
if (low < high)
{
privot = partion(a, low, high);
Qsort(a, low, privot - 1);
Qsort(a, privot + 1, high);
}
}
void Quicksort(int a[], int len)
{
Qsort(a, 0, len - 1);
}
4).归并排序
基本思想:与快速排序相反,选择排序是先排序再分组,归并排序是先分组再进行排序。归并过程为:比较a[i]和a[j]的大小,若a[i]≤a[j],则将第一个有序表中的元素a[i]复制到r[k]中,并令i和k分别加上1;否则将第二个有序表中的元素a[j]复制到r[k]中,并令j和k分别加上1,如此循环下去,直到其中一个有序表取完,然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。
归并排序是稳定排序。平均时间复杂度为O(nlog2n), 最坏时间复杂度为O(nlog2n),空间复杂度为O(n);
//对划分的序列进行排序,并放入新的序列中
void Merge(int a[], int des[], int low, int mid, int high)
{
int i = low;
int j = mid + 1;
int k = low;
while ((i < mid) && (j < high))
{
if (a[i] < a[j])
des[k++] = a[i++];
else
des[k++] = a[j++];
}
while (i <= mid) 一个有序表取完,将有序表中剩余的元素复制到剩下的单元。
des[k++] = a[i++];
while (j <= high)
des[k++] = a[j++];
}
//递归的划分序列,直到总序列中只有一个元素及low = high
void Msort(int a[], int des[], int low, int high, int max)
{
if (!a) return;
int mid = 0;
if (low == high)
{
des[low] = a[low];
}
else
{
mid = (low + high) / 2;
int *space = malloc(sizeof(int)* max);
if (!space)
return;
else
{
Msort(a, space, low, mid, max);
Msort(a, space, mid + 1, high, max);
Merge(space, des, low, mid, high);
}
free(space);
}
}
5).插入排序
基本思想:每步将一个待排序的记录,按照其大小插入到前面的已经排序好的序列中,直到数据全部插入为止。
插入排序是稳定排序,平均时间复杂度为O(n²),最坏时间复杂度为O(n²),空间复杂度为O(1);
void InsertSort(int a[], int len)
{
if (!a) return;
int i = 0, j = 0;
int k = 0;
int tmp = 0;
for (i = 1; i < len; i++)
{
k = i;
tmp = a[k];
for (j = i - 1; (j >= 0) && (a[j] > tmp); j--)
{
a[j + 1] = a[j];
k = j;
}
a[k] = tmp;
}
}