面试题：冒泡排序，选择排序，插入排序，快速排序，归并排序，堆排序

面试题之各种排序，现整理如下：

冒泡排序

最常见排序之一，主要算法思想是：最下面数据依次与其相邻数据相比较，如果比相邻数据小，则交换，以此类推，直到最小的数放在最上层，形似冒泡，代码如下：

void bubblesort(int a[],int len)
{
for (int i = 0; i < len; i++)
{
for (int j = len -1; j > i; j--)	//顺序比较相邻两个数，将小者冒上来
{
if (a[j] < a[j-1])
{
int temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}
}
}
}

从冒泡排序的代码中可以看出，对于由n个数的成员来说，他们的比较次数是:(n-1) + (n-2) + (n-3) + ...+ 1 = n*(n-1)/2 = (n^2 - n)/2,因此其平均时间复杂度为O(n^2)，最好时间复杂度为O(n).

选择排序，插入排序

将选择排序和插入排序放在一起，因为个人觉得选择排序和插入排序比价类似，但是又有所区别，选择排序是从为排序好的数据中选择出最小的数，假设为a，然后将排在已经排好序的后面；而插入排序是将某一数字，假设为b，从后往前依次与前面已经排好序的数相比较，直到找到比b小的数，将b插到此数的前面。

综上：选择排序是从未排序数据中找出最小数排在已排好序后面，插入排序是将数据插入到已排好序数组中。

插入排序代码如下：

void insertsort(int a[], int len)
{
int i ,j;
for(i = 0; i < len; i ++)
{
int temp = a[i];
for(j = i-1; j >= 0; j --) //从已排序数组中最后一个数开始与i比较，找到最后一个比i大的数，将插入在该数前面
{
if (a[j] > temp )
{
a[j+1] = a[j];
}
else
break;
}
a[j+1] = temp;
}
}

选择排序代码如下：

void selectsort(int a[], int len)
{
for (int i = 0; i < len; i++)
{
int k = i;   //使用k记录未排序数组中的下标
for (int j = i; j < len; j++)
{
if (a[j] < a[k])
{
k = j;
}
}
if (i != k)
{
int temp = a[i];
a[i] = a[k];
a[k] = temp;
}
}
}

从上面可以看出，选择排序和插入排序的平均时间复杂度都是O(n^2)

快速排序：

快速排序采用了分治法，即取一个参照数据，假设为a，将小于a的数据放在a的左边，将大于a的数据放在a的右边，然后分别对a左边和右边的数据采用同样的方式，举例：假设待排序数据为 5 3 6 4 9 7 ，选取5为参考数据，则经过一次快速排序后，应该变为4 3 5 6 9 7，此时小于5的数字被排在了左边，大于5的数字被排在了右边，然后分别再对 4 3 5 和 6 9 7 采用同样方法，直到排序完成。

快速排序代码如下：

int partition(int a[],int first, int last)
{
int low = first;
int high = last;
int key = a[first]; //取第一个数为参考值

while (low < high)
{
while (low < high && a[high] >= key)
high --;
a[low] = a[high];

while(low < high && a[low] <= key)
low ++;
a[high] = a[low];
}
a[low] = key;

return low;
}

void  quicksort(int a[],int first, int last)
{
if (first < last)  //递归退出的条件，一定要有
{
int ret = partition(a, first, last);
quicksort(a, first, ret);
quicksort(a, ret+1, last);
}
}

快速排序的平均时间复杂度是O(n*logn),最坏时间复杂度是O(n^2),空间复杂度是O(logn)

归并排序

归并排序是递归的将数组分成若干个已经排好序的微型数组，然后两两对若干个数组进行比较合并，比如 5 3 6 4 9 7，经过不断递归分为了 （5 3）（6 4）（9 7），进过合并排序后变为（3 5）（4 6）（7 9），然后再经过合并排序变成了（3 4 5 6）（7 9），经过最后一次合并变成了（3 4 5 6 7 9 ）

归并排序代码如下：

//合并两个有序数组（其实是一个数组的两部分，以mid为分割），将小的数放进临时数组里
void mergesort_t::merge(int a[], int first, int mid, int last)
{
int indexL = first;
int indexR = mid + 1;
int len = last - first + 1;
int *temp = new int[len];
int i = 0;

while (indexL<=mid && indexR<=last)
{
if (a[indexL] <= a[indexR])
{
temp[i++] = a[indexL++];
}
if (a[indexL] > a[indexR])
{
temp[i++] = a[indexR++];
}
}

while(indexL <= mid)
{
temp[i++] = a[indexL++];
}

while (indexR <= last)
{
temp[i++] = a[indexR++];
}

for (int j=0; j<i;j++)
{
a[first + j] = temp[j];
}
delete [] temp;
}

//先递归拆分数组，然后合并有序数组
void mergesort_t::mergesort(int a[], int first, int last)
{
if (first < last)
{
int mid = (first + last)/2;
mergesort(a, first, mid);
mergesort(a, mid+1, last);
merge(a, first, mid, last);
}
}

归并排序的平均最好和最坏时间复杂度是O(nlogn),但是其空间复杂度是O(n).

堆排序

堆排序是将待排序数组化为最大堆(即堆顶为最大值)，然后将堆顶(即最大值)与数组最后一个数字互换，然后重新化为最大堆，然后将堆顶与倒数第二个数字互换。。。以此循环，直到全部排序完成。

堆排序代码如下：

//创建某个父节点的最大堆
void heapsort_t::rootheapsort(int a[], int len, int index)
{
//获取左右子节点
int left = getleftchildindex(index);
int right = getrightchildindex(index);
int maxindex = index;

//判断左右子节点与父节点的大小
if (left < len &&  a[maxindex] < a[left])
{
maxindex = left;
}
if (right < len && a[maxindex] < a[right])
{
maxindex = right;
}

//如果当前最大的数不是父节点，则与当前父节点互换,且互换完成后要重新堆排序
if (maxindex != index)
{
int temp = a[index];
a[index] = a[maxindex];
a[maxindex] = temp;
rootheapsort(a, len, index);
}
}

//创建某整个数组的最大堆
void heapsort_t::createMaxHeap(int a[], int len)
{
int startIndex = getparentindex(len-1); //从第一个父节点开始对所有父节点执行堆化

for (int i = startIndex; i >= 0; i--)
{
rootheapsort(a, len, i);
}
}

//堆排序
void heapsort_t::heapsort(int a[], int len)
{
//将目前的堆顶与最后一个元素互换，然后继续堆化剩余的，然后将再堆化后的堆顶变为倒数第二个元素，以此循环，直到整个数组遍历完。
for (int i=len-1; i>=0; i--)
{
int temp = a[i];
a[i] = a[0];
a[0] = temp;
rootheapsort(a,i,0);
}
}

堆排序的时间复杂度是O(nlogn),空间复杂度是1.