严蔚敏数据结构习题第十章

第十章作业题目10.1 10.3 10.4 10.6 10.12 10.23 10.27 10.29 10.31 10.32 10.42 10.43。作业提交入口已开通，截止日期6月13日
https://wenku.baidu.com/view/4feba71baa956bec0975f46527d3240c8447a13d.html
https://blog.csdn.net/weixin_30699955/article/details/95661878
http://www.doc88.com/p-8059220558076.html
十大排序 https://www.runoob.com/w3cnote/ten-sorting-algorithm.html

1

答案的 https://blog.csdn.net/qq_45846199/article/details/110442703
总：https://blog.csdn.net/xiaoxiaojie12321/article/details/81380834
https://www.runoob.com/w3cnote/radix-sort.html
快速排序 https://www.runoob.com/w3cnote/quick-sort.html
堆排序 https://www.cnblogs.com/chengxiao/p/6129630.html

3 算法稳定性

https://zhidao.baidu.com/question/525229984242427805.html
https://blog.csdn.net/qq_43152052/article/details/100078825
10.3❷试问在10.1题所列各种排序方法中，哪些是稳定的？哪些是不稳定的？并为每一种不稳定的排序方法举出一个不稳定的实例。
1.快速排序比如序列为 5 3 3 4 3 8 9 10 11，现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱
2.希尔排序由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱
3.堆排序堆的结构是节点i的孩子为2i和2i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n 的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n /2-1, n/2-2, …1这些个父节点选择元素时，就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法。

4

（1）n-1
（2）1+2+…+n-1=

6 和29 奇偶交换

https://blog.csdn.net/shuiyixin/article/details/85252224
https://blog.csdn.net/lemon_tree12138/article/details/50605563

（1）当奇数交换和偶数交换都没有发生交换的时候就结束了
（2）2；n+2

#include <stdio.h>
#include <stdlib.h>void Sort(int a[], int l)
{int temp;int i, j;int m = 1, n = 1;//如果奇排序过程中有元素交换，m为1，否则为0；如果偶排序过程中有元素交换，n为1，否则为0。//当mn同时为0时，说明奇偶都没有交换，这个时候说明数据有序。while (m || n){for (i = 1; i < l - 1; i=i+2){if (a[i] > a[i + 1]){temp = a[i];a[i] = a[i + 1];a[i + 1] = temp;m = 1;}elsem = 0;}for (j = 0; j < l - 1; j = j + 2){if (a[j] > a[j + 1]){temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;n = 1;}elsen = 0;}}
}

12 堆

（2）12，24，33，29，33，56，48, 65， 86， 70
(4) 05,28,20,23，40,38,29,61,35,76,56,100 交换3次

23 直接插入

http://www.aikanwk.com/tiku/1710.html
10.23❷试以L.r[k+1]作为监视哨改写教科书10.2.1节中给出的直接插入排序算法。其中，L.r[1…k]为待排序记录且k<MAXSIZE。

void InsertSort(SqList& L)
{int k = L.length;int i, j;for (i = k - 1; i > 0; i--){if (L.r[i].key > L.r[i + 1].key){L.r[k + 1] = L.r[i];  // 复制为监视哨for (j = i + 1; L.r[k + 1].key > L.r[j].key, j <= k; j++)//防止越界L.r[j - 1] = L.r[j];//记录往前移}}}

27 双向冒泡

https://wenku.baidu.com/view/4cd655b465ce0508763213b7.html
编写一个双向起泡的排序算法，即相邻两遍向相反方向起泡。

#include <stdio.h>
#include <stdlib.h>void BiBubble(int r[], int n)
{int flag, i=0, j, temp;flag = 1;//printf("%d ", flag);while (flag == 1){flag = 0;for(j=n-i-1;j>i;j--)//逆序冒泡，找最小if (r[j - 1] > r[j]){flag = 1;temp = r[j];r[j] = r[j - 1];r[j - 1] = temp;}for (j = i; j < n - i-1; j++)//正序冒泡，找最大if (r[j] > r[j + 1]){flag = 1;flag = 1;temp = r[j];r[j] = r[j + 1];r[j + 1] = temp;}i++;    }
}int main()
{int a[10];int i, j;for (i = 0, j = 10; i < 10; i++, j--)a[i] = j;BiBubble(a, 10);for (i = 0; i < 10; i++)printf("%d ", a[i]);
}

29 奇偶交换排序

按10.6题所述编写奇偶交换排序的算法。

31

https://blog.csdn.net/happy_bigqiang/article/details/53364141?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-2.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-2.control

#include <stdio.h>
#include <stdlib.h>
#define max 10
typedef struct
{int key;//...
}RedType;typedef struct
{RedType r[max];// r[0]用作哨兵单元int length;
}SqList;void ti_31(SqList& L)
{int i = 0, j = L.length;while (i != j){while (i < j && L.r[i].key < 0)i++;if (i < j)L.r[0] = L.r[i];while (i < j && L.r[j].key >= 0)j--;if (i < j){L.r[i++] = L.r[j];L.r[j] = L.r[0];}}
}int main()
{SqList l;l.length = 3;l.r[1].key = 3;l.r[2].key = -2;l.r[3].key = -9;ti_31(l);for (int i = 1; i < 4; i++)printf("%d ", l.r[i].key);
}

当关键字为正数的记录全部排在关键字为负数的记录之前时，需要移动的次数达到最大: n/2.

32 红旗问题

https://blog.csdn.net/qq_42191317/article/details/102779113?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-0&spm=1001.2101.3001.4242
荷兰国旗问题：设有一个仅由红、白、蓝三种颜色的条块组成的条块序列。请编写一个时间复杂度为O(n)的算法，使得这些条块按红、白、蓝的顺序排好，即排成荷兰国旗图案。

#include <stdio.h>
#include <stdlib.h>
#define max 10
enum color{red,white,blue};
typedef struct
{int c[max];int length;
}FlagList;void swap(int a[], int i, int j)
{int temp = a[i];a[i] = a[j];a[j] = temp;
}void HFlag(FlagList& l)
{int i, j, k;int ll = l.length;for (i = 0, j = 0; j < ll;){k = l.c[j];if (k == 0){swap(l.c, i, j);i++;j++;}else if (k == 1)j++;else if (k == 3){swap(l.c, j, ll-1);ll--;}}
}int main()
{int a[10];int i, j;for (i = 0, j = 10; i < 10; i++, j--)a[i] = j;FlagList l;l.c[8];//不能赋初值，因为还有个key
}

42 中值记录

序列的“中值记录”指的是：如果将此序列排序后，它是第┌n/2┐个记录。试写一个求中值记录的算法。

#include <stdio.h>
#include <stdlib.h>
#define max 10
typedef struct
{int key;//...
}RedType;typedef struct
{RedType r[max + 1];// r[0]闲置或用作哨兵单元int length;
}SqList;int MidElement(SqList& L)
{int i, j, k, n;RedType temp;if (L.length == 0)return 0;for (i = 1; i < L.length; i++)//排序{k = i;temp = L.r[i];for(j=i+1;j<=L.length;j++)if (temp.key > L.r[j].key){temp = L.r[j];k = j;}temp = L.r[i];L.r[i] = L.r[k];L.r[k] = temp;}if (L.length % 2 == 0)//找中值n = L.length / 2;elsen = L.length / 2 + 1;return L.r[n].key;
}

43 ？

已知记录序列a[1…n]中的关键字各不相同，可按如下所述实现计数排序：另设数组c[1…n]，对每个记录a[i]，统计序列中关键字比它小的记录个数存于c[i]，则c[i]=0的记录必为关键字最小的记录，然后依c[i]值的大小对a中记录进行重新排列，试编写算法实现上述排序方法。

#include <stdio.h>
#include <stdlib.h>
#define max 10
typedef struct
{int key;//...
}RedType;typedef struct
{RedType r[max + 1];// r[0]闲置或用作哨兵单元int length;
}SqList;void sort_43(SqList& L)
{int i, j;SqList t;int c[max];t = L;for (i = 1; i <= t.length; i++) //初始化c[]c[i] = 0;for (i = 1; i < t.length - 1; i++)//对每个记录统计比它小的关键字个数{for (j = i + 1; j <= t.length; j++){if (t.r[i].key < t.r[j].key)c[j]++;elsec[i]++;}}for (i = 1; i < t.length + 1; i++)//排序L.r[c[i] + 1] = t.r[i];
}