堆排序
堆排序是将序列人为的类比做堆来处理,分为大堆和小堆,大堆就是双亲结点大于孩子结点,这里的孩子自身可能也是“双亲”,那么这个“双亲”还要大于它的孩子,小堆于此相反。
当所有结点满足这个大堆的条件后,最上面的根节点肯定是这个序列中最大的数,然后我们将这个数与最后一个结点交换,再对除了最后一个结点外的所有结点进行大堆处理,依次反复,最终会将这个序列排成从小到大的顺序。
下面,让我们结合图来详细的说明:
以序列a[] = {29, 17, 35, 6, 12, 31, 28, 15}为例;
整个遍历的过程是从最后一个非叶子节点开始,依次将所有非叶子结点遍历完成;
首先将序列按照顺序排成二叉树的模样:
这里我们需要知道几个知识点:
1.最后一个非叶子结点的下标为:length / 2 - 1 ;
2.假设根节点的下标为i,其左孩子的下标为2 * i + 1,右孩子的下标为2 * i + 2;
第一次遍历:
6是最后一个非叶子节点,比较其与孩子结点的大小,发现6<15,于是交换两者的内容,并将15作为双亲,继续与它的孩子进行比较,但15并没有孩子,于是第一次遍历结束,结果如下图;
第二次遍历:
35是倒数第二个非叶子结点,比较其与孩子结点的大小,35大于它所有的孩子结点,所以不进行交换,本次遍历结束;
第三次遍历:
17是倒数第三个非叶子结点,比较其与孩子结点的大小,17大于它所有的孩子结点,所以不进行交换,本次遍历结束;
第四次遍历:
29是倒数第四个非叶子结点,比较其与孩子结点的大小,发现29<35,于是交换二者内容(此时35在下标为0的位置,29在下标为2的位置)
之后,再将29作为双亲与它的孩子结点比较大小,发现29 < 31,于是交换二者内容(此时31在下标为2的位置,29在下标为5的位置)
最后,将29与其孩子结点进行比较,并没有孩子结点,本次遍历结束。
通过这四次遍历,这个二叉树已经满足大堆的要求,并且最大数35在最上面,对应于下标0的位置。于是将35与最后一个结点交换内容,(此时35的下标为7)并对除去35以外的所有结点再次执行大堆操作。
新一轮遍历
第一次遍历:
31作为最后一非叶子结点,与其孩子进行比较,并没有比它大的孩子,于是本次遍历结束;
第二次遍历:
17是倒数第二个非叶子结点,比较其与孩子结点,并没有比它大的孩子结点,于是本次遍历结束;
第三次遍历:
将6与其孩子结点比较大小,并且最大的孩子结点是31,所以将31与6进行交换(此时,31在下标为0的位置,6在下标为2的位置)
将6再与孩子结点进行比较,将最大孩子结点与其交换内容(此时,29在下标为2的位置,6在下标为5的位置)
再次将6与其孩子结点进行比较,并不存在孩子结点,所以本次遍历结束;
通过这三次遍历,这个二叉树已经满足大堆的要求,并且最大数31在最上面,对应于下标0的位置。于是将31与最后一个结点交换内容,(此时31的下标为6)并对除去31以外的所有结点再次执行大堆操作。
新一轮遍历:
第一次遍历:
29是最后一个非叶子结点,比较其与孩子结点的大小,并没有比它大的孩子结点,此次遍历结束;
第二次遍历:
17是倒数第二个非叶子结点,比较其与孩子结点的大小,并没有比它大的孩子结点,此次遍历结束;
第三次遍历:
28与其叶子结点比较大小,发现29>28,于是交换二者内容(此时29在下标为0的位置,28在下标为2的位置)
将28与其孩子结点比较大小,并没有大于它的孩子结点,于是本次遍历结束;
通过这三次遍历,将最大数29移到下标为0的位置,于是将 29与最后一个结点交换内容,即6在下标为0的位置,29在下标为5的位置,再对除去29以外的所有数进行大堆操作;
之后的过程以前面相同,就不再赘述。
下面附上代码:
#include <stdio.h>
void Swap(int *a, int *b)
{
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
void Adjust(int array[], int parent, int len) //大堆操作,调整二叉树满足所有双亲结点大于其孩子结点
{
int child;
child = 2 * parent + 1;
while(child < len)
{ //如果存在右孩子,并且右孩子大于左孩子,则将右孩子与双亲进行比较
if((child + 1) < len && array[child] < array[child + 1])
{
child++;
}
if(array[child] > array[parent]) //如果孩子大于双亲,则交换二者内容
{
Swap(&array[child], &array[parent]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}
void BigHeapSort(int arr[], int len)
{
int i, length;
for(i = len / 2 - 1; i >= 0; i--)
{
Adjust(arr, i, len);
}
length = len - 1;
while(length > 0) //将最大数与最后一个结点内容交换,并对除去最大数以外的所有数再次进行大堆处理
{
Swap(&arr[0], &arr[length]);
Adjust(arr, 0, length);
length--;
}
}
int main()
{
int i, length;
int a[] = {29, 17, 35, 6, 12, 31, 28, 15};
length = sizeof(a) / sizeof(a[0]);
BigHeapSort(a, length);
for(i = 0; i < length; i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
归并排序
利用递归与分治技术将数据序列划分为越来越小的半子表,再对半子表排序,最后再用递归步骤将排好序的半子表合并成为越来越大的有序序列。
原理如下:对于给定的一组记录,首先将两个相邻的长度为1的子序列进行归并,得到n/2个长度为2或者1的有序子序列,在将其两两归并,反复执行此过程,直到得到一个有序的序列为止。
具体如何实现,结合图片详解:
以序列a[] = {29, 17, 35, 6, 12, 31, 28, 15}为例;
第一步、我们将这个序列拆分成最小单元,也就是一个个的数据。
第二步、将半子表一一合并成有序的序列,那么在合并的过程中,就涉及到了排序。我们以左边为例进行说明。
首先对29与17进行比较,将较小数17放在数组tmp中(此处及之后的说明中,都将合并后的数存放在数组tmp中),大数29放在后面,35与6的情况一样。那么排序后结果如下图:
其次,将(17, 29)与(6, 35)进行比较,两个数组分别用 i 和 j 表示下标。先比较下标0的数值,将小数6放在数组tmp的最前面,此时将 j 指向1, i 依旧指向0;
接着,比较下标 i 与下标 j 对应的数值。注意,此时 i 依旧指向0,即比较17与35,发现17小于35,于是把17写在6的后面,此时 i 指向下标1,j 还指向下标1;
此时,比较29与35,将小数29写在17后面,循环结束,但还剩余一个数35,于是最后将35写到数组tmp的最后,左边所有归并就完成了。
下面附上代码:
#include <stdio.h>
#include <stdlib.h>
void Merge(int array[], int start, int middle, int end)
{
int i, j, k, n1, n2;
n1 = middle - start + 1; //前半部分序列长度
n2 = end - middle; //后半部分序列长度
int *L = (int *)malloc(n1 * sizeof(int)); //前半部分临时数组
int *R = (int *)malloc(n2 * sizeof(int)); //后半部分临时数组
for (i = 0, k = start; i < n1; i++, k++) //将原序列的前半部分复制到临时数组中
{
L[i] = array[k];
}
for (i = 0, k = middle + 1; i < n2; i++, k++) //将后序列的前半部分复制到临时数组中
{
R[i] = array[k];
}
// 先比较对应位置的数值,将最小值(假设是下标L[0])写入原序列后,i 变成 1
// 继续比较下标L[1]与R[0],如果L[1] < R[0],继续将L[1]写入原序列,i变成2
//i不再满足循环条件(假设本次左半部分长度为2),循环结束,但R数组中还有两个数未写入
//那么,就将这两个数按顺序写入序列
for (k = start, i = 0, j = 0; i < n1 && j < n2; k++)
{
if (L[i] < R[j])
{
array[k] = L[i];
i++;
}
else
{
array[k] = R[j];
j++;
}
}
if (i < n1) //如果L数组中还有剩余的数,则按顺序写入原数组中
{
for (j = i; j < n1; j++, k++)
{
array[k] = L[j];
}
}
if (j < n2) //如果R数组中还有剩余的数,则按顺序写入原数组中
{
for (i = j; i < n2; i++, k++)
{
array[k] = R[i];
}
}
free(L);
free(R);
}
void MergeSort(int array[], int start, int end)
{
int middle;
int i;
if (start < end)
{
middle = (start + end) / 2; //将序列一分为二
MergeSort(array, start, middle); //左半部分,递归继续拆分,直到单个
MergeSort(array, middle + 1, end); //右半部分,递归继续拆分,直到单个
Merge(array, start, middle, end); //待整个序列全部拆分完毕后,从最低层开始排序合并
}
}
int main()
{
int i = 0;
int a[] = {29, 17, 35, 6, 12, 31, 28, 15};
int length = sizeof(a) / sizeof(a[0]);
MergeSort(a, 0, length -1);
for (i = 0 ; i < length; i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
基数排序
基数排序:是一种借助多关键字排序的思想对单逻辑关键字进行关系的方法。基数排序不需要进行记录关键字间的比较。
主要有两个过程:
1)分配,先从个位开始,根据位值(0-9)分别放到0~9号桶中(比如53,个位为3,则放入3号桶中)
2)收集,再将放置在0~9号桶中的数据按顺序放到数组中
我想,大多数人看到上述的解释,对什么是基数排序并不会有太深的理解,那么下面结合图片进行分析讲解;
首先,什么叫做 借助多个 关键字 排序,对于 整型序列 而言,我们将这样的 多关键字 理解为 数位(个位,十位,百位,千位。。。),也就是说对 整型序列 通过数位 进行排序,那么到底怎么排的呢?
以序列 int a[] = {229, 17, 35, 6, 12, 31, 28, 102} 为例;
我们知道 每个 数位 都是 0 ~ 9,第一次 按照 个位的顺序 进行排序
那么,第二次 我们按照 十位 的顺序进行排序
接着,第三次 我们按照 百位 的顺序进行排序
因为,序列中 最大数 也只有百位,所以排序 排到这里 就已经结束了,最终结果也显而易见。
附上代码,对一些语句会进行说明:
#include <stdio.h>
#include <stdlib.h>
void RadixCountSort(int *index,int *a,int len)
{
int i;
int *count=(int *)malloc(sizeof(int)*10);
for(i=0;i<10;i++) // 清空桶
{
count[i]=0;
}
for(i=0;i<len;i++) // 对应桶内 存放 数的个数; 对应的数位 是多少 就在 对应的 桶 位置 + 1,比如 个位 为 3,就填到 3 的位置
{
//index[i] 表示 原序列中第 i 个数 的对应数位 的值,例如,第一次,求 个位 时,index[0] = 0,那么在 count[0]的值就 + 1
count[index[i]] ++;
}
for(i=1;i<10;i++) // 前面的个数 == 下标加 1
{
count[i]=count[i] + count[i - 1];
}
int *sort=(int *)malloc(sizeof(int)*len);
for(i=len-1;i>=0;i--)
{
count[index[i]] --; // 计算下标 , 最终结果是 下标 + 1,所以要减去 1 才是真正的下标
sort[count[index[i]]] = a[i]; // 将原序列 重新排序
}
for(i=0;i<len;i++)
{
a[i]=sort[i];
}
free(sort);
free(count);
}
void RadixSort(int *a,int len)
{
int i , x=1;
int tmp=1;
int *radix=(int *)malloc(sizeof(int)*len); // radix 保存 每一轮对应数位 的值
while(x)
{
tmp=tmp * 10;
x=0;
for(i=0;i<len;i++)
{
radix[i]=a[i] % tmp; // 例如:当 tmp = 100 时,求出十位 和 个位 的数, 121 % 100 = 21
radix[i]=radix[i] / (tmp / 10); // 21 / (100 / 10) = 2;
if(a[i] / tmp > 0)
{
x = 1; // 判断是否需要 下一轮 循环
}
}
RadixCountSort(radix,a,len); // 每一轮求出 对应数位的值 以后 重新排序
}
free(radix);
}
int main()
{
int i;
int len;
int a[]={100, 8 , 1099, 6, 1, 300, 405, 604, 102, 806, 706, 504};
len=sizeof(a)/sizeof(a[0]);
RadixSort(a,len);
for(i=0;i<len;i++)
{
printf("%d \n",a[i]);
}
return 0;
}
八种排序的比较
排序方法 | 最好时间 | 平均时间 | 最坏时间 | 辅助存储 | 稳定性 |
---|---|---|---|---|---|
选择排序 | O(n^2) | O(n^2) | O(n^2) | O(1) | 不稳定 |
插入排序 | O(n) | O(n^2) | O(n^2) | O(1) | 稳定 |
冒泡排序 | O(n) | O(n^2) | O(n^2) | O(1) | 稳定 |
希尔排序 | O(n^1.3) | O(nlogn) | O(n^2) | O(1) | 不稳定 |
快速排序 | O(nlogn) | O(nlogn) | O(n^2) | O(logn) | 不稳定 |
堆排序 | O(nlogn) | O(nlogn) | O(nlogn) | O(1) | 不稳定 |
归并排序 | O(nlogn) | O(nlogn) | O(nlogn) | O(kn) | 稳定 |
基数排序 | O(kn) | O(kn) | O(kn) | O(n) | 稳定 |