标签：
激励我写博文有很大的原因是，在校电面的时候，被问到了很多基础算法问题。当时瞬间懵哔了。痛定思痛。决定好好复习下常用的基础算法。
一).常见的排序算法。
1).简单选择排序。
基本思想：每一趟在后面n-1个待排的数据中选出一个最小（大）的数据作为有序序列的第i个元素。之后依次循环遍历。
简单选择排序是稳定排序，平均时间复杂度为O(n²)，最坏时间复杂度为O(n²)，空间复杂度O(1)；
1 static void swap_sort(int a[], int i, int j)
2 {
3 int tmp = 0;
4 tmp = a[i];
5 a[i] = a[j];
6 a[j] = tmp;
7 }
1 void SelectSort(int a[], int n)
2 {
3 if (a == NULL || n < 0)
4 return;
5 int i = 0, j = 0, k = 0;
6 7 for (; i < n; i++)
8 {
9 k = i;
10 for (j = i + 1; j < n; j++)
11 {
12 if (a[j] < a[k])
13 k = j;
14 }
15 swap_sort(a, i, k);
18 }
19 }
2).冒泡排序算法
基本思想：将序列中第一个元素与第二个元素进行比较，若为逆序（升序）a[2] > a[1](a[2] < a[1])则交换，然后再比较第二个元素与第三个元素，依次进行，每趟选出一个最大（小）值。冒泡排序已选择排序的区别：选择排序是每趟与最小（大）值交换，冒泡排序是每趟移动相邻的位置。
小技巧： 可以在冒泡排序中定义一个变量，用于表示冒泡排序受否排列好了。如果要有一个已经基本有序的序列，则可以减少循环次数。
冒泡排序属于交换排序，是稳定排序。平均时间复杂度为O(n²)，最坏时间复杂度为O(n²)，空间复杂度O(1)；
1 void BubbleSort(int a[], int len)
2 {
3 int i = 0, j = 0;
4 int exchange = 1; //定义变量起到优化排序的作用
5 int tmp = 1;
6 for (; (i < len - 1) && exchange; i++)
7 {
8 exchange = 0;
9 for (j = 0; j < len - 1 - i; j++)
10 {
11 if (a[j + 1] < a[j])
12 {
13 14 swap_sort(a, j, j + 1);15 16 exchange = 1;
17 }
18 }
19 }
20 }
3).快速排序
基本思想：通过一趟排序将序列分割成独立的两部分，其中一部分的所有数据要比另一部分的所有数据小。基准数据排在两个部分的中间。依次快排两个模块。现在这个算法分为两个过程，一个是根据基准数据划分模块，一个是递归的划分模块及排列数据。
快速排序也属于交换排序，不稳定排序。平均时间复杂度为O(nlog2n), 最坏时间复杂度为O(n²),空间复杂度为O(nlog2n)；
1 void QuickSort(int a[], int len)
2 {
3 QSort(a[], 0, len - 1);
4 }
5
6 void QSort(int a[], int low, int high)
7 {
8 int privot = 0;
9 if (low < high)
10 {
11 privot = partion(a, low, high);
12 QSort(a, low, privot -1);
13 QSort(a, privot + 1, high);
14 }
15 }
16
17 int partion(int a[], int low, int high)
18 {
19 int privot = a[low];
20
21 while(low < high)
22 {
23 while((low < high) && (a[high] > privot))
24 high--;
25 swap_sort(a, low, high);
26 while((low < high) && (a[low] <= privot))
27 low++;
28 swap_sort(a, low, high);
29 }
30 return low;
31 }
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 MergeSort(int a[], int len)
{
MSort(a, a, 0, len - 1, len);
}
void MSort(int a[], int des[], int low, int high, int max)
{
int mid = 0;
if (low == high)
{
des[low] = a[high];
}
else
{
mid = (low + high) / 2;
int *space = (int *)malloc(sizeof(int *) * max);
if (space == NULL)
return;
else
{
MSort(a, space, low, mid, max);
MSort(a, space, mid + 1, high, max);
Merge(space, des, low, mid ,high);
}
free(space);
}
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(i >= mid)
des[k++] = a[j++];
}
5).插入排序
基本思想：每步将一个待排序的记录，按照其大小插入到前面的已经排序好的序列中，直到数据全部插入为止。
插入排序是稳定排序，平均时间复杂度为O(n²),最坏时间复杂度为O(n²)，空间复杂度为O(1);
void InsetSort(int a[], int len)
{
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;
}
标签：
原文地址：http://www.cnblogs.com/evincto/p/4634477.html
