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

2023-10-03 15:16:40

第十章作业题目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;
			}
			else
				m = 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;
			}
			else
				n = 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;
	else
		n = 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]++;
			else
				c[i]++;
		}
	}
	for (i = 1; i < t.length + 1; i++)//排序
		L.r[c[i] + 1] = t.r[i];
}

码农公寓

1