目录
1 排序
1.1 排序的稳定性
多关键字的排序最终都可以转化为单个关键字的排序，例如学生成绩按照总分和单科成绩排序，也可以把总分和单科成绩拼成一个字符串排序。排序不仅是针对主关键字，对于次关键字，待排序的记录序列中可能存在两个或两个以上的关键字相等的记录，排序结果可能会存在不唯一的情况。
假设Ki=Kj(1<=i<=n，1<=j<=n，i!=j)，且在排序前的序列中Ri领先于Rj(即i<j)。如果排序后Ri仍领先于Rj，则称所用的排序方法是稳定的；反之，若可能使得排序后的序列Rj领先Ri，则称所用的排序方法是不稳定的。
1.2 内排序与外排序
内排序是在排序整个过程中，待排序的所有记录全部被放置在内存中。
外排序是由于排序的记录个数太多，不能同时放置在内存，整个排序过程需要在内存外存之间多次交换数据才能进行。
内排序分为：插入排序、交换排序、选择排序和归并排序。
/* 交换L中数组r的下标为i和j的值 */
void swap(SqList *L, int i, int j) {
int temp = L->r[i];
L->r[i]=L->r[j];
L->r[j]=temp;
}2 冒泡排序
冒泡排序是一种交换排序，它的基本思路是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。
2.1 交换排序
void BubbleSort0(SqList L){
int i,j;
for(int i=1; i<L->length; i++) {
for(j=i+1; j<=L->length; j++) {
if(L->r[i] > L->r[j]) {
swap(L,i,j);
}
}
}
}如图：
2.2 冒泡排序算法
复杂度O(
)
void BubbleSort(SqList *L) {
int i,j;
for(i=1; i<L->length; i++) {
for(j=L->length-1; j>=i; j--) { /*注意j是从后往前循环*/
if(L->r[j] > L->r[j+1]) {
swap(L,j,j+1);
}
}
}
}
3 简单选择排序
简单选择排序就是通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i（1<=i<=n）个记录交换。复杂度O()
/* 对顺序表L作简单选择排序 */
void selectSort(SqList *L) {
int i,j,min;
for(i=1; i<L->length; i++) {
min = i;
for(j=i+1; j<=L->length; j++) {
if(L->r[min] > L->r[j]) {
min = j;
}
}
if(i != min) {
swap(L,i,min);
}
}
}
4 直接插入排序
直接插入排序的基本操作是将一个记录插入到已经排好序的表中，从而得到一个新的、记录新增1的有序表。复杂度O()
/* 对顺序表L作直接插入排序 */
void insertSort(SqList *L) {
int i,j;
for(i=2; i<=L->length; i++) {
if(L->r[i] < L->r[i-1]) {
L->r[0] = L->r[i];
for(j=i-1; L->r[j]>L->r[0]; j--) {
L->r[j+1] = L->r[j];
}
L->r[j+1] = L->r[0];
}
}
}5 希尔排序
将相距某个“增量”的记录组成一个子序列，这样才能保证在子序列内分别进行直接插入排序后得到的结果是基本有序而不是局部有序
/* 对顺序表L作希尔排序 */
void shellSort(SqList *L) {
int i,j;
int increment = L->length;
do{
increment = 1+increment/3; /* 增量序列 */
for(i=increment+1; i<L->length; i++) {
if(L->r[i] < L->r[i-increment]) { /* 需将L->r[i]插入有序增量子表 */
L->r[0] = L->r[i];
for(j=i-increment; j>0&&L->r[0] < L->r[j]; j-=increment) {
L->r[j+increment] = L->r[j]; /* 记录后移，查找插入位置 */
}
L->r[j+increment]=L->r[0]; /* 插入 */
}
}
}while(increment > 1);
}例如：
increment=9/3+1=4；表示每隔4隔元素之间相比，下标1与下标为5的数据相比
如果increment=4/3+1=2;表示每隔2隔元素相比，下标为1与下标为3相比
希尔排序的时间复杂度为O(
/2)，增量序列的最后一个增量值必须等于1才行，希尔排序不是一种问额定的排序
6 堆排序
堆是具有下列性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。
堆排序就是利用堆进行排序的方法，基本思路：将待排序的序列构造成一个大顶堆，此时整个序列的最大值就是对顶的根结点。将它移走(其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值)，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次小值，如此反复执行，便能得到一个有序序列了。
如上图，图1是一个大顶堆，90为最大值，将90与20互换，如图2所示，此时90就成了整个堆序列的最后一个元素，将20经过调整，使得除90以外的结点继续满足大顶堆定义，如图3所示，然后在考虑将30与80互换
要实现这样的一个算法，需要考虑两个问题：
1，如何由一个无序序列构建成一个堆？
所谓的将待排序的序列构建成为一个大顶堆，其实就是从下往上、从右到左，将每个非终端结点(非叶结点)当作根结点，将其和其子树调整成大顶堆。时间复杂度O(n
)
/* 已知L->r[s..m]中记录的关键字除L->r[s]之外均满足堆的定义 */
/* 本函数调整L->r[s]的关键字，使L->r[s..m]成为一个大顶堆 */
void headAdjust(SqList *L, int s, int m){
int temp,j;
temp = L->r[s];
for(j=2*s; j<=m; j*=2) { /*沿关键字较大的孩子结点向下筛选*/
if(j<m && L->r[j] < L->r[j+1]){/*j<m说明不是最后一个结点，如果L.r[j]<L.r[j+1]则说明左孩子小于右孩子 */
++j; /*j为关键字中较大的记录的下标*/
}
if(temp >= L->r[j]){
break; /*rc应插入在位置s上*/
}
L->r[s] = L->r[j];
s=j;
}
L->r[s] = temp; /*插入*/
}这里j的变量为什么是从2*s开始？为什么是j*=2递增？原因是二叉树性质5，因为完全二叉树，当前结点序号是s，其左孩子的序号一定是2s，右孩子的序号一定是2s+1。
2，如果在输出堆顶元素后，调整剩余元素成一个新的堆
/* 对顺序表L进行堆排序 */
void heapSort(SqList *L){
int i;
for(i=L->length/2; i>0; i--){ /* 把L中的r构建成一个大顶堆 */
heapAdjust(L, i, L->length);
}
for(i=L->length; i>1; i--) {
swap(L, 1, i); /*将堆顶记录和当前未经排序子序列的最后一个记录交换*/
heapAdjust(L, 1, i-1); /*将L->r[1..i-1]重新调整为大顶堆*/
}
}
7 归并排序
”归并“一词的中文含义就是合并、并入的意思，而在数据结构中的定义是将两个或两个以上的有序表组合成一个新的有序表。
归并排序就是利用归并的思想实现的排序方法，它的原理是假设初始序列含有n个记录，则可以堪称是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到不小于n/2个长度为2或1的有序子序列；在两两归并，..，如此反复，直至得到一个长度为n的有序序列为止，这种排序方法称为2路归并排序，时间复杂度O(nlogn)
/* 对顺序表L作归并排序 */
void mergeSort(SqList *L){
mSort(L->r, L->r, 1, L->length);
}
/* 将SR[s..t]归并排序为TR1[s..t] */
void mSort(int SR[], int TR1[], int s, int t) {
int m;
int TR2[MAXSIZE+1];
if(s==t) {
TR1[s] = SR[s];
} else {
m=(s+t)/2; /* 将SR[s..t]平分为SR[s..m]和SR[m+1..t] */
mSort(SR, TR2, s, m); /* 递归将SR[s..m]归并为有序的TR2[s..m] */
mSort(SR, TR2, m+1, t); /*递归将SR[m+1..t]归并为有序TR2[m+1..t]*/
merge(TR2, TR1, s, m, t); /*将TR2[s..m]和TR2[m+1..t],归并到TR1[s..t]*/
}
}
/* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] */
void merge(int SR[], int TR[], int i, int m, int n) {
int j,k,l;
for(j=m+1,k=i;i<=m && j<=n; k++) {
if(SR[i]<SR[j]) {
TR[k]=SR[i++];
} else {
TR[k]=SR[j++];
}
}
if(i<=m){
for(l=0; l<=m-i; l++){
TR[k+1]=SR[i+1]; /*将剩余的SR[i..m]复制到TR*/
}
}
if(j<=n){
for(l=0; l<=n-j; l++){
TR[k+1]=SR[j+1]; /*将剩余的SR[j..m]复制到TR*/
}
}
}8 快速排序
快速排序的基本思路是：通过一趟排序将待排记录分割称独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。
/* 对顺序表L作快速排序 */
void quickSort(SqList *L){
qSort(L,1,L->length);
}
/* 对顺序表L中的子序列L->r[low..high]作快速排序 */
void qSort(SqList *L, int low, int high) {
int pivot;
if(low<high) {
pivot=partition(L,low,high);/*L->r[low..high]一分为2,计算轴值pivot*/
qSort(L,low,pivot-1); /*对低子表递归排序*/
qSort(L,pivot+1,high); /*对高子表递归排序*/
}
}
/* 交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置 */
/* 此时在它之前(后)的记录均不大(小)于它 */
int partition(SqList *L, int low, int high) {
int pivotkey;
pivotkey = L->r[low]; /* 用子表的第一个记录作轴记录 */
while(low<high) {
while(low<high&&L->r[high]>=pivotkey) {
high--;
}
swap(L,low,high); /* 将此轴记录小的记录交换到低端 */
while(low<high&&L->r[low]<=pivotkey) {
low++;
}
swap(L,low,high); /* 将此轴记录大的记录交换到低端 */
}
return low; /* 返回轴所在位置 */
}
扫一扫
9348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
