作业1

排序问题的总结

一插入排序

1思想：将一个新记录插入到一个含有条记录的有序表中，使得新表依然有序。2伪代码；

template

void Insert(const T&e, T*a, int i)

{//Insert e into the ordered sequence[1:i]such that the

//resulting sequence a[1:i+1] is also ordered.

//The array a must have space allocated for at least i+2 elements.

a[0]=e;

While(e

{

a[i+1]=a[i];

i--;

}

a[i+1]=e;

}

template

void InsertionSort(T*a, const int n)

{//Sort a[1:n] into nondecreasing order.

For (int j=2; j<=n;j++){

T temp =a[j];

Insert (temp, a, j-1);

}

3复杂度；

对InsertionSort的分析：最坏情况下，Insert(e, a, i)在插入之前需要进行i+1次比较。因此，Insert的复杂度为O(i)。InsertionSort调用Insert的情况为：

i=j-1=1,2,...n-1.因此，InsertionSort的复杂度为:

n-1

O( (i+1))=O(n*2)

i=1

插入排序最坏情况下的复杂度均为O(n*2);

插入排序的最佳情况：O(n);

二快速排序

1思想：

首先在所有待排序记录中选出一项作为枢轴，然后将所有关键字小于等于枢轴的记录排在枢轴的左边，所有关键字大于等于枢轴的记录排在枢轴的右边，最后，再分别对左右两部分进行排序。（递归调用快速排序）

2伪代码；

template

void QuickSort(T *a, const int left, const int right)

{ // Sort a[left:right] into nondecreasing order.

// a[left] is arbitrarily chosen as the pivot. Variables i and j

// are used to partition the subarray so that at any time a[m] ≤ pivot, m < i,

// and a[m] ≥ pivot, m > j. It is assumed that a[left] ≤ a[right + 1].

if (left < right) {

int i = left,

j = right + 1,

pivot = a[left];

do {

do i++; while (a[i] < pivot);

do j--; while (a[j] > pivot);

if (i < j) swap (a[i], a[j]);

} while (i < j);

swap (a[left], a[j]);

QuickSort(a, left, j - 1);

QuickSort(a, j + 1, right);

}

}

3复杂度；

对QuickSort的分析：快速排序在最坏的情况下的表现为O(n*2);

快速排序的平均情况：O(nlog n);

O(n) time to partition an array of n elements.

T(n) is the time taken to sort a list of n records.

T(n)<=c n +2T(n/2),

<=c n +2( c n/2+ 2T(n/4))

<=2cn + 4T(n/4)

.........

<=c n log n +n T(1) =O(n log n)

三归并排序(迭代归并）

1 思想：

将输入表看作n个有序的长度为1的子表

第一趟，子表两两归并，生成n/2个长度为2的子表（n为奇数，则有一子表长度为1）

第二趟，这n/2个子表再两两归并生成n/4个子表。

每趟归并都将子表数减半。

最终剩下了一个子表，归并自然也就结束了。

2 伪代码；

template

void MergePass(T *initList, T *resultList, const int n, const int s)

{// Adjacent pairs of sublists of size s are merged from

//initList to resultList. n is the number of records in initList.

for (int i = 1; // i is first position in first of the sublists being merged

i <= n-2*s+1; // enough elements for two sublists of length s?

i+ = 2*s)

Merge(initList, resultList, i, i + s -1, i + 2 * s -1);

// merge remaining list of size < 2 * s

if ((i + s -1) < n ) Merge(initList, resultList, i, i + s -1, n);

else copy(initList + i, initList + n + 1, resultList + i);

} （一趟归并）

template

void MergeSort(T *a,const int n)

{// Sort a[1:n] into nondecreasing order.

T *tempList = new T[n+1];

// l is the length of the sublist currently being merged

for (int l =1; l < n; l*= 2)

{

MergePass(a, tempList, n, l);

l*=2;

MergePass(tempList, a, n, l); // interchange the role of a and tempList }

delete [] tempList;

}

3复杂度；

对的分析：函数对初始记录进行了数趟归并。

第一趟：子表长度l=1,

第二趟：l=2,

第i 趟：l= 2*i-1.

则所需趟次：i= log l +1=log n +1每O(n)

所以T(n)= n x (log n +1)→O(n log n)

四堆排序

1 思想：

（1)将待排序的记录序列构造成一个堆；

（2）选出堆中所有记录的最大者即堆顶记录，然后将它从堆中移走（通常将堆顶记录和堆中最后一个记录交换）；

（3）将剩余的记录再调整成堆，这样又找出了次大的记录，以此类推，直到堆中只有一个记录为止。

2 伪代码；

template

void Adjust(T *a, const int root, const int n)

{// Adjust binary tree with root root to satisfy heap property. The left and right

//subtrees of root already satisfy the heap property. No node index is > n.

T e = a[root];

// find proper place for e

for (int j =2*root; j <= n; j *=2) {

if (j < n && a[j] < a[j+1]) j++; // j is max child of its parent

if (e >= a[j]) break; // e may be inserted as parent of j

a[j / 2] = a[j]; // move jth record up its parent node

}

a[j / 2] = e;

}

template

void HeapSort(T *a, const int n)

{// Sort a[1:n] into nondecreasing order.

for (int i = n/2; i >= 1; i--) // heapify

Adjust(a, i, n);

for (i = n-1; i >= 1; i--) // sort

{

swap(a[1], a[i+1]);// swap first and last of current heap

Adjust(a, 1, i); // heapify

}

}

3 复杂度；

对HeapSort的分析：设2*k-1≤n≤2*k，则树有k层，且第k层的结点树≤2*k-1。在第1个循环中，每个孩子的结点都会调用一次Adjust，所需的时间则为每层结点数乘以结点可达的最远距离的和，即如下：

T(n)= ∑2*i-1(k-i)=2*0(k-1) +2*1(k-2) + 2*2(k-3)+....+2*k-1(0)

1<=i<=k

=∑2*k-i-1(i)= 2*k-1∑i/2*i ≤n∑i/2*i=n(1/2+2/2*2+3/2*3...+(k-1)/2*k-1) 1≤i≤k-1 1≤i≤k-1 1≤i≤k-1

<2n =O(n)

Maximum tree depth(第二循环结构)

Time complexity O(n log n)

五关键字排序

1 思想：

待排序记录R1,R2,…,Rn可采用d位r基箱排序，

关键字用基数r进行分解，

每个关键字被分为d位，

每位取值范围0～r-1 (十进制：0～9，二进制：0～1)，

r是基，每个进制需要r个箱子，每个箱中的记录将组成一个链。

2 伪代码；

void RadixSort(Element *list, const int d, const int n)

// Records list~=~(list[1],~... ,~list[n]) are sorted on the keys key[0],^... ,^key[d-1]

// The range of each key is 0~(<=~key[i]~<~radix. radix is a constant.

// Sorting within a key is done using a bin sort.

const int radix = 10;

{ int e[radix], f[radix]; // queue pointers

for (int i = 1; i <= n; i++) list[i].link = i+1;

list[n].link = 0; int current = 1;

for (int i = d-1; i >= 0; i--) // sort on key key[i], key[2] key[1] key[0]

{ for (int j = 0; j < radix; j++) f[j] = 0; // initialize bins to empty queues for (;current; current = list[current].link) { // put records into queues

int k = list[current].key[i]; //k=list[1].key(2)=9

if (f[k] == 0) f[k] = current; //if f[9]==0 then f[9]=1

else list[e[k]].link = current;

e[k] = current; //e[9]=1

}

for (int j = 0; f[j] == 0; j++); // find first nonempty queue

current = f[j]; int last = e[j];

for (int k = j+1; k < radix; k++) // concatenate remaining queues

if (f[k]) {

list[last].link = f[k];

last = e[k];

}

list[last].link = 0;

for (int q = current; q; q= list[q].link)

cout << list[q].key[0] << list[q].key[1] << list[q].key[2] << " , "; cout << endl;

}

}

class Element

{

public:

int key[3];

int other;

int link;

Element(){other = 0;};

};

void main()

Element *b = new Element[11];

Element e;

e.key[0] = 1; e.key[1] = 7; e.key[2] = 9; b[1] = e;

e.key[0] = 2; e.key[1] = 0; e.key[2] = 8;b[2] = e;

e.key[0] = 3; e.key[1] = 0; e.key[2] = 6;b[3] = e;

e.key[0] = 0; e.key[1] = 9; e.key[2] = 3;b[4] = e;

e.key[0] = 8; e.key[1] = 5; e.key[2] = 9;b[5] = e;

e.key[0] = 9; e.key[1] = 8; e.key[2] = 4;b[6] = e;

e.key[0] = 0; e.key[1] = 5; e.key[2] = 5;b[7] = e;

e.key[0] = 0; e.key[1] = 0; e.key[2] = 9;b[8] = e;

e.key[0] = 2; e.key[1] = 7; e.key[2] = 1;b[9] = e;

e.key[0] = 0; e.key[1] = 3; e.key[2] = 3;b[10] = e;

RadixSort(b, 3, 10);

}

3 复杂度；

对Radixsort的分析：RadixSort对数据进行d趟操作，每趟用时O(n+r)。因此，算法的时间复杂度为O(d(n+r))。其中d的大小依赖于r的选取和最大的关键字。选择不同的r会导致不同的时间复杂度。

课本P22

6、考虑下面的算法，回答下列问题：

int Stery(int n) //n为非负整数

{

S=0;

for (i=1;i<=n;i++)

S=S+i*i;

return S;

}

（1）、该算法求的是S=1*1+2*2+3*3+……+n*n，即前n个数的平方和；（2）、该算法的基本语句是S=S+i*i;

（3）、基本语句执行了n次；

（4）、该算法的效率类型是线性；

（5）、

（6）、

7、使用扩展递归技术求解下列递推关系式：

（1）、{41

3(1)1()n T n n T n =->=

解：()3(1)3(2)=3(1)43n n T n T n T n T --=-=-==*……224()n O n ≤=

（2）、{11

2(/3)1()n T n n n T n =+>=

解：假定3k n =，将递推式像下面这样扩展：

()2(3)T n T n n =+22(2(

3)3)

T n n n =++ =1

12(1)2233k k k n n T n --+++?+…… 032()2k k i i ==∑k 13122312

k +-=?-（） 113233()k k k n O n ++=-≤==

8、考虑下面的递归算法，回答下列问题：

int Q(int n) //n 为整数

{

if (n ==1) return 1;

else return Q(n -1)+2*n -1;

}

（1）、该算法求的是前n 个奇数的和

（2）、当n=3时，(3)(2)231(1)221231T T T =+?-=+?-+?-

(211)(2

21)(231)13=?-+?-+?-=++=

（3）、该算法递推关系式为{1

1(1)211()n T n n n T n =-+*->= ()(1)21(2)2(1)121T n T n n T n n n =-+*-=-+*--+*-

1321n =+++*-……22()n O n ==

（4）、转换为非递归算法，其代码为：

int Q(int n) //n 为整数

{

int m =0;

for (int i =1;i <=2*n -1;i =i +2)

m =m +i;

return m;

}