《算法导论》第14章 数据结构的扩张 (1)动态顺序统计

《数据结构扩张》是《算法导论》第三部分的最后一章。在介绍学习了这么多种数据

结构之后，简要介绍了当这些基本数据结构不满足需求时，如何扩张它们来满足需求。

这才是学习算法的目的，能够根据需求选择合适的数据结构和算法，并在无法满足需求

时能够扩张它。这才是对算法的思想和本质的学习！

可以将本章看做深入学习的前奏吧，因为紧接着就要开始进入第四部分《高级设计和分析

技术》了。那么赶快来看看如何扩张数据结构，然后就进入高级部分的学习吧！

1.如何扩张数据结构？

1）选择基础数据结构

2）确定要在基础数据结构中添加哪些信息

3）验证可用基础数据结构上的基本操作来维护新添加的信息

4）设计新的操作

下面来看一个简单的数据扩张的例子 - 动态顺序统计树。《算法导论》中选用红黑树

作为基础数据结构，这里为了简单，用最简单的二叉查找树来实现。这样我们可以集中

注意力在数据结构扩张的方法上。

2.动态顺序统计树

在第九章《中位数和顺序统计》中，我们曾研究过如何求数组中的元素的顺序统计量。

如查找最大值、最小值、第 i 小的值等等。其中求第 i 小元素时采用了随机快速排序的

RANDOMIZED-PARTITION划分方法，从而达到了Θ(n)的期望运行时间。

本节要研究的是动态顺序统计量，与之前的有些类似，首先我们来看面对这个需求，

如何选择合适的数据结构，并在必要时进行简单的扩张。

1）选择基础数据结构

我们面对的需求是维护动态集合，即数据可能会频繁的插入和删除，固定长度的数组

显然不适合这种情形。所以我们可以选择二叉查找树作为基础数据结构，但基本的

二叉查找树实现顺序统计功能是很低效的，所以还要添加新的域来扩张它。

2）确定要在基础数据结构中添加哪些信息

我们选择在每个结点添加一个新的size域，来保存每棵子树的大小（包含的结点树，包括

此根结点自身）。更自然的想法是新加一个rank域，直接保存每个结点的顺序统计量，

但这样插入和删除时可能会麻烦一些，参见习题14.1-6。

3）验证可用基础数据结构上的基本操作来维护新添加的信息

如前所述，添加size而不是rank域是为了只对原有数据结构略作改动，就足以维护附加信息，

这是比较理想的情况。如果添加rank域，当插入一个最小元素时，所有结点的rank域都要变。

4）设计新的操作

新的操作就是我们需求中所需的，OS-SELECT求顺序统计量为 i 的结点和OS-RANK求一个

结点的顺序统计量。

3.实现源码

下面来看实现代码，这里只列出BST实现的改动部分，着重来看新加的操作和对BST的影响。

typedef struct _BSTNode {
     struct _BSTNode *left, *right, *parent;
     int key;
     char *value;
     int size;
} BSTNode;

void bst_insert(BSTNode **root, BSTNode *newNode)
{
     // Locate insert location
     BSTNode *pNode = NULL;
     BSTNode *node = *root;
     while (node != NULL) {
          pNode = node;
          node->size += 1;//维护size域
          if (newNode->key < node->key)
               node = node->left;
          else
               node = node->right;
     }
     
     // Link newNode to pNode
     newNode->parent = pNode;

     // Link pNode to newNode
     if (pNode == NULL)
          *root = newNode;
     else if (newNode->key < pNode->key)
          pNode->left = newNode;
     else
          pNode->right = newNode;          
}

BSTNode *bst_delete(BSTNode **root, BSTNode *delNode)
{
     BSTNode *pNode = delNode;//维护size域
     while ((pNode = pNode->parent) != NULL)
          pNode->size -= 1;

     // Real delete node: delNode or its successor 
     // (if delNode has both left and right child)
     BSTNode *realDelNode;
     if (delNode->left && delNode->right)
          realDelNode = bst_successor(delNode);
     else
          realDelNode = delNode;

     // Child of real delete node
     BSTNode *childNode;
     if (delNode->left)
          childNode = realDelNode->left;
     else
          childNode = realDelNode->right;

     // Link realDelNode child and parent
     if (childNode)
          childNode->parent = realDelNode->parent;

     if (realDelNode->parent == NULL)
          *root = childNode;
     else if (realDelNode == realDelNode->parent->left)
          realDelNode->parent->left = childNode;
     else
          realDelNode->parent->right = childNode;

     // Copy successor data to delNode (override)
     // if real delete node is not delNode but its successor          
     if (realDelNode != delNode) {
          delNode->key = realDelNode->key;
          delNode->value = realDelNode->value;
          delNode->size = realDelNode->size;//维护size域
     }

     return realDelNode;
}

BSTNode *bst_os_select(BSTNode *node, int i)
{
     if (node == NULL)
          return NULL;

     int r = 1;
     if (node->left != NULL)
          r = node->left->size + 1;

     if (i == r)
          return node;
     else if (i < r)
          return bst_os_select(node->left, i);
     else
          return bst_os_select(node->right, i - r); 
}

int bst_os_rank(BSTNode *root, BSTNode *node)
{
     int r = 1;
     if (node->left != NULL)
          r += node->left->size;

     while (node != root) {
          if (node == node->parent->right)
               r += node->parent->left->size + 1;
          node = node->parent;
     }
     return r;
}

4.运行情况详细分析

现在以查找第 i = 17小的元素来看OS-SELECT的执行过程。

    |                                                                                                                                                    |

    |                                                                                                                                                    |

[  3, 7,  10, 12, 14,14, 16, 17, 19,   20,21,      21, 26, 28,       30,35, 38, 39,41,        47]

1.从根结点26开始，其顺序统计量 r = 26左子结点size + 1 = 13 < i，则递归OS-SELECT(26右子结点, i - r)，

即OS-SELECT(结点41，4)。

[  3, 7,  10, 12, 14,14, 16, 17, 19,   20,21,      21, 26, 28,       30,35, 38, 39,41,        47]

2.根结点变为41，i = 4，r = 5 + 1 = 6 > i，递归OS-SELECT(41的左子结点, i )，即OS-SELECT(结点30, 4)。

[  3, 7,  10, 12, 14,14, 16, 17, 19,   20,21,      21, 26, 28,       30,35, 38, 39,41,        47]

3.根结点变为30，i = 4，r = 1 + 1 = 2 < i，递归OS-SELECT(结点38, 2)。

[  3, 7,  10, 12, 14,14, 16, 17, 19,   20,21,      21, 26, 28,       30,35, 38, 39,41,        47]

4.根结点变为38，i = 2，r = 1 + 1 = 2 == i，找到了！结点38即为顺序统计量17的元素。

[  3, 7,  10, 12, 14,14, 16, 17, 19,   20,21,      21, 26, 28,       30,35, 38, 39,41,        47]

看到OS-SELECT的实现了吧，跟第九章的RANDOMIZED-SELECT多么相似。从根结点开始遍历，

首先计算根节点的顺序统计量设为r，若比 i 小则继续处理根节点的左子树，否则处理右子树。

我们可以将每次递归处理的根节点node看做RANDOMIZED-PARTITION返回的划分元素A[q]，

若 i 比A[q]的顺序统计量小则继续处理较小的数组部分，否则处理大的那部分。如出一辙！