作业1

{ // 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].
{ 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
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);
} a[j / 2] = e; }
template <class T> 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);
n-1
O( (i+1))=O(n*2)
i=1 插入排序最坏情况下的复杂度均为 O(n*2); 插入排序的最佳情况：O(n);
二 快速排序 1 思想： 首先在所有待排序记录中选出一项作为枢轴，然后将所有关键字小于等于枢轴的右边，最后， 再分别对左右两部分进行排序。（递归调用快速排序） 2 伪代码； template <class T> void QuickSort(T *a, const int left, const int right)
int k = list[current].key[i]; //k=list[1].key(2)=9
排序问题的总结 一 插入排序 1 思想：将一个新记录插入到一个含有条记录的有序表中，使得新表依然有序。 2 伪代码； template<class T> 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]) {
a[i+1]=a[i]; i--; } a[i+1]=e; }
template<class T> 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 的复杂度为:
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
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]
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]
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); } （一趟归并）
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
} } 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),
template <class T> 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.
} 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 伪代码；
// 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
<=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 <class T> 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?