课程笔记 09：数据结构（清华） 列表-排序器

同向量一样，有序列表在去重算法上也有着巨大的效率优势。采用下述算法，则时间复杂度仅为O(n)：

int List<T>::uniquify() { //成批剔除重复元素，效率更高

if (_size < 2) return 0; //平凡列表自然无重复

int oldSize = _size; //记录原规模

ListNodePosi(T) p; ListNodePosi(T) q; //依次指向紧邻的各对节点

for (p = header, q = p->succ; trailer != q; p = q, q = q->succ) //从自左向右扫描

if (p->data == q->data) { remove(q); q = p; } //若p和q雷同，则删除后者

return oldSize - _size; //列表规模变化量，即被删除元素总数

}

虽然在列表元素有序的条件下并不能改变在渐进意义下查找算法的复杂度，但是在常系数意义下的改进 还是很大的。有序列表利于使用逆向查找，其实现如下：

ListNodePosi(T) List<T>::search(T const& e, int n, ListNodePosi(T) p) const

{

while (0 <= n--) //对于p的最近的n个前驱，从右向左逐个比较

if (((p = p->pred)->data) <= e) break; //直至命中、数值越界或范围越界

return p; //返回查找终止的位置

}

下面重点介绍三类排序算法：

1.插入算法：在上述search方法下，进行插入排序是很容易的，其实现如下：

void List::insertionSort(ListNdoePosi(T) p, int n)

{

for (int r = 0; r < n; r ++)

{

insertAsSucc(search(p.data, r, p), p.data);

p = p.succ; remove(p.pred);

}

}

2.选择排序：对于列表而言，在使用起泡排序时无序将最大元素步步交换才到达指定位置，只要选出了最大元素，那么交换只需一步即可。因此，我们需要写出查找最大元素的方法，其实现如下：

ListNodePosi(T) List<T>::selectMax(ListNodePosi(T) p, int n)

{

ListNodePosi(T) max = p;

ListNodePosi(T) cur = p;

while ( -- n )

{

if ((cur = cur.succ).data > max.data)

max = cur;

}

return max;

}

往下就可以实现选择排序算法了：

void List<T>::selectionSort(ListNodePosi(T) p, int n)

{ 

ListNodePosi(T) head = p->pred;

ListNodePosi(T) tail = p;

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

tail = tail->succ; //待排序区间间为(head, tail)

while (1 < n)//在至少还剩两个节点之前，在待排序区间内

{ 

ListNodePosi(T) max = selectMax(head->succ, n); //找出最大者

insertBefore(tail, remove(max)); //将其移动至无序区间末尾

tail = tail->pred; n--;

}

}

3.归并排序。与向量时的讨论一样，我们要先设计好二路归并的算法，之后才能利用递归实现归并排序。

void List<T>::merge(ListNodePosi(T) p, int m, List<T> & L, ListNodePosi(T) q, int n)

{

ListNodePosi(T) x = p.pred;

while ( -- n )

{

if ( m && (q.data >= p.data) )

{

if (q == (p = p.succ)) break;

n --;

}

else

{

insertBefore(p, L.remove((q = q.succ).pred));

m --;

}

}

p = x.succ;

}

在此基础上，可以设计归并排序的递归了：

void List<T>::mergeSort(ListNodePosi(T)& p, int n)

{

if (n < 2) return; //若待排序范围已足够小，则直接返回；否则...

int m = n / 2; //以中点为界

ListNodePosi(T) q = p; for (int i = 0; i < m; i++) q = q->succ; //均分列表

mergeSort(p, m); mergeSort(q, n - m); //对前、后子列表分别排序

merge(p, m, *this, q, n - m); //归并

}