算法导论 第八章答案

8.2-4 :在O(1)的时间内，回答出输入的整数中有多少个落在区间[a...b]内。给出的算法的预处理时间为O(n+k)

算法思想：利用计数排序，由于在计数排序中有一个存储数值个数的临时存储区C[0...k]，利用这个数组即可。

#include

using namespace std;

//通过改编计数排序而来，因为有些部分需要注释掉

void counting_sort(int*&a, int length, int k, int*&b, int*&c);

int main()

{ const int LEN =100;

int*a =newint[LEN];

for(int i =0; i < LEN; i++)

a[i] = (i -50)*(i -50) +4;

int* b =new int[LEN];

const int k =2504;

int* c =new int[k +1];

counting_sort(a, LEN, k, b, c);

//这里需要注释掉

//for(int i = 0; i < LEN; i++)

//cout<

int m; int n;

while(cin>>m>>n)

{ if(m >n)

cout<<"区间输入不对"<

else { if(n <0) cout<<"个数为"<<0<

else if(m <=0&& n <= k) cout<<"个数为"<

else if(n > k && m >0) cout<<"个数为"<

else if(n > k && m <=0) cout<<"个数为"<

else cout<<"个数为"<

}} return 0; }

void counting_sort(int*&a, int length, int k, int*&b, int*&c)

{ for(int i =0; i < k +1; i++) c[i] =0;

for(int i =0; i < length; i++) c[a[i]]++;

for(int i =1; i < k +1; i++) c[i] = c[i] + c[i-1];

//这里需注释，因为对c数组内的元素进行减减操作会使其改变

/*for(int i = length - 1; i >= 0; i--)

{

b[c[a[i]] - 1] = a[i];

c[a[i]]--;

}*/ }

PS:计数排序的总时间为O(k+n)，在实践中，如果当k = O(n)时，我们常常采用计数排序，

这时其运行时间为O(n)

8.3-4 :说明如何在O(n)时间内，对0到n^2 - 1之间的n个整数进行排序。

算法思想：1.把这n个数看成n进制数，那么每个数只有两位，因而循环只需两次

2.调用通用的基数排序(在这写着，留着以后用)

在此题中我选择n = 15，即数组中有15个数，依次为0, 3, 8, ..., 224，但是将顺序打乱

采用的是基数排序，在实践中，其排序时间为O(d*(n+k))，但很耗内存，有时甚至比快速排序更快，具体应用再看。

#include

#include

using namespace std;

void radix_sort(int a[], const int d, const int length, int radix);

int getBit(int m, int i, int radix);

int pow2(int a, int b);

int main()

{ //数组长度const int LEN =15;

int a[LEN] = {35, 48, 0, 8, 15, 80, 99, 3, 24, 168, 195, 224, 63, 120, 143}; //多少位const int d =2;

//基数const int radix =15;

//在这调用的是通用的基数排序算法，可以任意改变基数radix， //但记得改变d，因为radix改变的话，数字的位数会改变， //最简单的是十进制改成二进制，位数激增 radix_sort(a, d, LEN, radix);

for(int i =0; i < LEN; i++) cout<

{ //存储a中每个元素的余数int* remainder =new int[length];

//统计余数(等同于计数排序中的c) int* c =new int[radix];

//保存排序之后的a int* b =new int[length];

for(int i =0; i < radix; i++) c[i] =0;

for(int i =0; i < d; i++) { for(int j =0; j < length; j++)

{ int temp = getBit(a[j], i, radix); remainder[j] = temp; c[temp]++; } for(int k =1; k < radix; k++) c[k] = c[k] + c[k -1];

for(int k =length-1; k >=0; k--)

{b[--c[remainder[k]]] = a[k];//c[remainder[k]]--;}

for(int k =0; k < radix; k++) c[k] =0;

for(int i =0; i < length; i++) a[i] = b[i]; }

delete remainder; delete c; delete b; }

//得到相应位上的数值int getBit(int m, int i, int radix)

{ return (m%(pow2(radix, i +1)))/pow2(radix, i); }

//只处理指数b>=0 int pow2(int a, int b)

{ if(b >0) { int result = a;

for(int i =0; i < b -1; i++) result = result*a; return result; }

else if(b ==0) return 1;

else {cout<<"不处理指数小于零的情况"<

思考题8-2以线性时间原地排序

假设有一个有n个数据记录组成的数组要排序，且每个记录的关键字的值为0或1。排序这样一组记录的一个算法应具备如下三个特性中的一部分。

1）算法的运行时间为O(n)。

2）算法是稳定的。

3）算法是原地排序的，它可以使用除输入数组以外的固定量的存储空间。

a）给出一个满足上述条件1和条件2的算法。

b）给出一个满足上述条件1和条件3的算法。

c）给出一个满足上述条件2和条件3的算法。

d）在a）~c）中给出的算法能否用来在O(bn)时间内排序，对有b位关键字的n个记录进行基数排序？如果行，说明如何做；如果不行，说明原因。

e）假设一个n个记录中每个的关键字都介于1到k之间。说明如何修改计数排序，使得可以在O(n+k)时间内对n个记录原地排序。除输入数组外，可另用O(k)的存储空间。你给出算法是稳定的吗？（提示：当k=3时应该如何做）

问题解答：

a）使用计数排序即可满足要求。

b）由于记录的关键字的值只有两种情况（0或1），可使用类似快速排序中PARTITION将数组划分为两个区域，一区域只含关键字值均为0，另一区域关键字均为1。

具体算法为：

PARTITON-SORT(A)

n ← lenght[A]

i ← 1

while A[i] = 0 and i ≤ n

do i ← i + 1

p← i

i ← i - 1

for j ← p to n

do if A[j] = 0

then i ← i + 1

exchange A[i] ? A[j]

c）使用插入排序或合并排序即可满足要求

d）

1、a）算法可以，对数组元素的每一位的排序都采用计数排序即可。

2、b）算法不可以，是由于快速排序算法的数组分割是不稳定的。

3、c）算法也不可以，是由于插入排序和合并排序的最坏运行时间为O(n^2)。