小肥柴慢慢手写数据结构（C篇）（5-1-2 BST的相关操作讨论）

目录

5-1-2-1 讨论的议题

（1）明确BST是一颗有顺序的树，即BST所有节点本质上是已经排序了的，很多文献资料中也称其为有序树、排序树等（planted plane tree，order tree） ；按照黑皮书之前的描述：
<1> 决定BST中节点位置的因素是键值key，当然我们在上一版代码中简单的把节点存储的数据Element直接看做key和val的替代，本帖将区分对待。
<2> 之前实现的BST是key唯一的，即每个元素仅存在一个节点，默认重复key的元素不处理。那么借助这个性质我们可以在后续的学习过程中将不带重复key的BST改造成集合Set，甚至借助key的唯一性改造成映射Map（没有Map概念的小伙伴可以把它理解成若干个键值对的集合）。

（2）既然树中的所有节点是有序的，那么自然会引申出几个问题：
Q1：类似findMax和findMin，实现RemoveMax和RemoveMin，即删除key值最大和key值最小的节点？
Q2：给定一个键值key，能否在给定BST中找到小于或者等于key的最大键值（floor），以及大于或者等于key的最小键值（ceil）？
Q3：在确保key唯一性的前提条件下，能否找到BST中排名为k的节点呢？（select操作）
Q4：反过来，若给定一个节点，是否能找出它在BST中的排名呢？（rank操作，是select的逆操作）
Q5：再进一步，给定一个key的上限hight和一个下限low，能否在BST中找到上下限范围内的所有节点呢？（姑且称之为range操作）

5-1-2-2 BST的升级

（1）为了方便编码实现上述4个问题的解决方案，且考虑到黑皮书中有关key的描述，我们决定将BST的节点struct升级，引入键key，值value（简记为val）的概念，并在节点中存储以当前节点为根的子树的所有节点数（N）

struct Node {
	int Key;
	double Val;
    struct Node *Left;
    struct Node *Right;
    int N;
};

对应生成的树结构示意如下：

（2）对应头文件及所含操作如下所示。为了实现范围查找（range），简单包装了一个ArrayList；如果想封装自己的Key，劳烦自己动手修改一下。

#ifndef _Tree_H
#define _Tree_H
#include <stdbool.h>
struct Node {
	int Key;
	double Val;
    struct Node *Left;
    struct Node *Right;
    int N;
};
typedef struct Node *TreeNode;

struct ArrayList {
	int *data;
	int len;
	int capacity;
};
typedef struct ArrayList *List;

TreeNode MakeEmpty(TreeNode T);
bool contains(int key, const TreeNode T);
TreeNode findMin(TreeNode T);
TreeNode findMax(TreeNode T);
int RetrieveKey(TreeNode T);
TreeNode Add(int key, double val, TreeNode T);
TreeNode Remove(int key, TreeNode T);
TreeNode RemoveMin(TreeNode T);
TreeNode RemoveMax(TreeNode T);
TreeNode getCeil(int key, TreeNode T);
TreeNode getFloor(int key, TreeNode T);
TreeNode select(int k, TreeNode T);
int rank(int key, TreeNode T);
List keys(int keyLow, int keyHigh, TreeNode T);
#endif  /* _Tree_H */

【注】为了方便理解添加了bool型，但在老版本编译器上（譬如我的DevC++）没有相关定义，需要引入stdbool.h去解决。

（3）与之前实现简单版BST相同的操的实现比较简单，核心问题有如下几个：
<1> 实际参与比较（compare）的是key不是val。
<2> 无论是添加操作或是删除操作，都需要维护表示以当前节点为根的子树中节点个数N。
<3> 与之前实现Array，Stack等等数据结构里的处理手法一致，在相关操作中维护N域，如果需要获取使用时直接返回该值即可（getSize）
【注】以下代码是对《算法4》中相关章节参考代码的重构。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "BSTree.h"

#define DEFAULT_CAPACITY (20)

TreeNode MakeEmpty(TreeNode T){
	if(T != NULL){
		MakeEmpty(T->Left);
		MakeEmpty(T->Right);
		free(T);
	}
	return NULL;
}

static int campareKey(int k1, int k2){
	/* return k1 - k2;*/
	if(k1 < k2)
		return -1;
	else if(k1 > k2)
		return 1;
	else
		return 0; 
}

int RetrieveKey(TreeNode T){
	return T == NULL ? INT_MIN : T->Key;
}

static int getSize(TreeNode T){
	return T == NULL ? 0 : T->N;
}

static int reSize(TreeNode T){
	return 1 + getSize(T->Left) + getSize(T->Right);
}

TreeNode Add(int key, double val, TreeNode T){
	if(T == NULL){
		T = malloc(sizeof(struct Node));
		if(T == NULL){
			printf("Create Tree ERROR\n");
			exit(0);
		}
		T->Key = key;
		T->Val = val;
		T->N = 1;
		T->Left = T->Right = NULL;
	} else {
		int cmp = campareKey(key, T->Key);
		if(cmp < 0)
			T->Left = Add(key, val, T->Left);
		else if(cmp >0)
			T->Right = Add(key, val, T->Right);
	} /*else key == T->Key, for repetition case update*/

	T->N = reSize(T);
	return T;
}

static TreeNode find(int key, const TreeNode T){
	if(T == NULL)
		return NULL;
		
	if(key < T->Key)
		return find(key, T->Left);
	else if(key > T->Key)
		return find(key, T->Right);
	else /*key == T->Key get it!*/
		return T;
}

bool contains(int key, const TreeNode T){
	return find(key, T) != NULL;
}

TreeNode findMin(TreeNode T){
	if(T == NULL)
		return NULL;
		
	return (T->Left == NULL) ? T : findMin(T->Left);
}

TreeNode findMax(TreeNode T){
	if(T == NULL)
		return NULL;
	
	return (T->Right == NULL) ? T : findMax(T->Right);
}

TreeNode Remove(int key, TreeNode T){
	if(T == NULL)
		return NULL;
	
	int cmp = campareKey(key, T->Key);
	if(cmp < 0)
		T->Left = Remove(key, T->Left);
	else if(cmp > 0)
		T->Right = Remove(key, T->Right);
	else{
		TreeNode tempCell;
		if(T->Left && T->Right){
			tempCell = findMin(T->Right);
			T->Val = tempCell->Val;
			T->Right = Remove(tempCell->Key, T->Right);
		} else {
			tempCell = T;
			if(T->Left == NULL) /* same as leaf node*/
				T = T->Right;
			else if(T->Right == NULL)
				T= T->Left;
			
			free(tempCell);
		}
	}
	
	if(T)
		T->N = reSize(T);
	
	return T;	
}

5-1-2-3 RemoveMin和RemoveMax

（1）以RemoveMin为例：
i.按照常理，最小key节点肯定左枝（left），但如果当前节点T没有左枝，因为右枝（right）所有节点key值均大于当前节点，那当前节点T就是需要删除的最小key节点，删除之后直接返回右枝即可。
ii.若T存在左枝，递归到左枝继续尝试删除key最小节点。
iii.完成删除动作后，需做一次reSize操作，重新阶段当前节点T以下的节点数量（即以T为根节点的子树中节点数），以维护N值。
（2）RemoveMax则与RemoveMin操作相反，将RemoveMin具体实现中Left和Right镜像互换就能解决问题。
（3）大家还能再次核对一下前一篇的remove实现，对左右叶子（或子树）的节点，删除时可以用左枝最大的节点去替换，也能用右枝最小的节点去替换。

TreeNode RemoveMin(TreeNode T){
	if(T->Left == NULL)
		return T->Right;
	
	T->Left = RemoveMin(T->Left);
	T->N = reSize(T);
	return T; 
}

TreeNode RemoveMax(TreeNode T){
	if(T->Right == NULL)
		return T->Left;
		
	T->Right = RemoveMax(T->Right);
	T->N = reSize(T);
	return T;
}

5-1-2-4 floor和ceil

简单介绍ceil，floor同理镜像即可：
<1> 如果当前节点就是天花板（ceil），直接返回。
<2> 如果当前节点key小于目标key，很自然的去右枝继续递归查找。
<3> 否则，尝试在左枝找到目标key的ceil；若能找到直接返回该ceil节点，否则当前节点就是ceil。
<4> 对找不到ceil或者floor的情况，在RetrieveKey中直接返回INT_MIN。

TreeNode getCeil(int key, TreeNode T){
	if(T == NULL)
		return NULL;
	
	int cmp = campareKey(key, T->Key);
	if(cmp == 0)
		return T;
	
	if(cmp > 0)
		return getCeil(key, T->Right);
	
	TreeNode leftNode = getCeil(key, T->Left);
	if(leftNode != NULL)
		return leftNode;
	else
		return T;
}

TreeNode getFloor(int key, TreeNode T){
	if(T == NULL)
		return NULL;
		
	int cmp = campareKey(key, T->Key);
	if(cmp == 0)
		return T;
		
	if(cmp < 0)
		return getFloor(key, T->Left);
		
	TreeNode rightNode = getFloor(key, T->Right);
	if(rightNode != NULL)
		return rightNode;
	else
		return T;
}

5-1-2-5 select和rank

select操作就是根据给定排名（k）尝试找到对应节点并返回该节点；如果要实现这个操作，必然需要知晓当前节点为根的子树的总节点数。大致思路如下：
<1> 先获取到左子树节点数量t（相当于已经计算出了右子树节点数量）。
<2> 若给定排名k小于t，那么目标节点一定在左枝，递归左枝继续查找；且左枝排序从0开始，排名不变依然为k。
<3> 否则目标节点在右枝，且排名偏移，从t+1开始记，则右枝实际查询目标key排名为$k-(t+1)=k-t-1$

TreeNode select(int k, TreeNode T){
	if(T == NULL)
		return NULL;

	int t = getSize(T->Left);
	if(t > k)
		return select(k, T->Left);
	else if(t < k)
		return select(k-t-1, T->Right);
	else
		return T;
}

本质上rank与select互为逆运算，相比select更容易理解，此处不再赘述；需要提醒的是：如果目标key不再树T中，直接返回-1排名。

int rank(int key, TreeNode T){
	if(T == NULL)
		return -1;
	
	if(!contains(key, T))
		return -1;
	
	int cmp = campareKey(key, T->Key);
	if(cmp < 0)
		return rank(key, T->Left);
	else if(cmp > 0)
		return 1 + getSize(T->Left) + rank(key, T->Right);
	else
		return getSize(T->Left);
}

5-1-2-6 range

（1） 用函数 List keys(int keyLow, int keyHigh, TreeNode T) 去解决该问题，即给定一个需要查询key的范围[keyLow，keyHigh]，然后找出符合条件的key的集合；实际上，在下一篇我们讨论中序遍历之后，能够找到更加优秀的解决方案。

（2）基于已实现的floor和ceil的手法，可以很容易找到处理思路：
<1> 若keyLow小于当前节点key，则需要继续在左枝查找可能在目标区间内的节点。
<2> 查询完左枝后，若当前节点在查询区间，则添加到输出列表list中。
<3> 若keyHigh大于当前节点key，则需要继续在右枝查找可能在目标区间内的节点。
<4> 简单封装一个ArrayList用于存储过滤出来的key集合。
<5> 可以用类似BFS的思维去理解这三段递归操作，不断扩散查找。

static List createList(){
	List L = malloc(sizeof(struct ArrayList));
	if(L == NULL){
		printf("Out of memery, create List fail\n");
		exit(0);
	}
	
	L->data = malloc(sizeof(int) * DEFAULT_CAPACITY);
	if(L->data == NULL){
		printf( "Out of memery, create list array fail\n" );
	    free(L);
		exit(0);
	}
	memset(L->data, 0, DEFAULT_CAPACITY);

	L->capacity = DEFAULT_CAPACITY;
	L->len = 0;

	return L;	
}

//这里的扩表/缩表操作，其实是本系列第一篇ArrayList中讨论相同问题的参考解决方案。
static int adjust(List list, int newCapacity){
	int *newData = malloc(sizeof(int) * newCapacity);
	if(newData == NULL){
		printf("\nresize array fail!\n");
		return -1;
	}
	memset(newData, 0, newCapacity);
	
	int *tmp = list->data;
	int i;
	for(i = 0; i < list->len; i++)
		newData[i] = list->data[i];
	list->data = newData;
	free(tmp);
	return 0;
}

static void collect(List list, int key){
	if(list == NULL){
		printf("list is null, resize error\n");
		exit(0);
	}
	
	if(list->len == list->capacity && adjust(list, list->capacity << 1) != 0){
		printf("\nadjust list error\n");
		exit(0);
	}
	
	list->data[list->len] = key;
	list->len++;
}

static void getKeys(int keyLow, int keyHigh, TreeNode T, List list){
	if(T == NULL)
		return;
	
	int cmplo = campareKey(keyLow, T->Key);
	int cmphi = campareKey(keyHigh, T->Key);
	if(cmplo < 0)
		getKeys(keyLow, keyHigh, T->Left, list);
	if(cmplo <= 0 && cmphi >= 0)
		collect(list, T->Key);
	if(cmphi > 0)
		getKeys(keyLow, keyHigh, T->Right, list);
}

List keys(int keyLow, int keyHigh, TreeNode T){
	List list = createList();
	getKeys(keyLow, keyHigh, T, list);
	return list;
}

测试代码如下（main.c）：

#include <stdio.h>
#include <stdlib.h>
#include "BSTree.h"

void test_rank(int key, TreeNode T){
	printf("key: %d rank is %d\n", key, rank(key, T));
}

void test_range(int low_key, int hight_key, TreeNode T){
	int i, len;
	List ret = keys(low_key, hight_key, T);
    printf("lo=%d , hi=%d, keys:", low_key, hight_key);
    if(ret){
		len = ret->len;
		for(i = 0; i < len; i++)
			printf(" %d ", ret->data[i]);
		free(ret->data);
		free(ret);
	}
	printf("\n");
}

int main(int argc, char *argv[]) {
	TreeNode T;
    int i, j;

    T = MakeEmpty(NULL);
    int arr[] = {21, 33, 0, -7, -15, 8, 40, 60, -100};
    int len = sizeof(arr)/sizeof(arr[0]);
	for(i = 0; i < len; i++){
		int key = arr[i];
		double val = arr[i]+10.0;
    	printf("add key=%d, val=%f\n", key, val);
		T = Add(key, val, T);	
	}
    printf("(1) Min key is %d, Max key is %d\n", RetrieveKey(findMin(T)), RetrieveKey(findMax(T)));

	T = Remove(-200, T);
	T = Remove(22, T);
	printf("(2) Min key is %d, Max key is %d\n", RetrieveKey(findMin(T)), RetrieveKey(findMax(T)));
	
	T = Remove(-100, T);
	T = Remove(60, T);
	printf("(3) Min key is %d, Max key is %d\n", RetrieveKey(findMin(T)), RetrieveKey(findMax(T)));
	
	T = RemoveMax(T);
	T = RemoveMin(T);
	printf("(4) Min key is %d, Max key is %d\n", RetrieveKey(findMin(T)), RetrieveKey(findMax(T)));
    
    printf("\n\n========== test: floor && ceil ==========\n\n");
	int test_keys[] = {21, 2, -3, 70, 53, 27, -101};
	int len_test = sizeof(test_keys)/sizeof(test_keys[0]);
	for(i = 0; i < len_test; i++)
		printf("get %d floor: %d, ceil: %d\n", test_keys[i], 
			RetrieveKey(getFloor(test_keys[i], T)), RetrieveKey(getCeil(test_keys[i], T)));
	
	printf("\n\n========= test: select =================\n\n");
	int k1 = 0;
	printf("select k = %d ,key is: %d\n", k1, RetrieveKey(select(k1, T)));
	int k2 = 3;
	printf("select k = %d ,key is: %d\n", k2, RetrieveKey(select(k2, T)));
	
	printf("\n\n========= test: rank ===============\n\n");
	int test_keys2[] = {21, -7, -101, 500};
	len_test = sizeof(test_keys2)/sizeof(test_keys2[0]);
	for(i = 0; i < len_test; i++)
		test_rank(test_keys2[i], T);
    
    printf("\n\n=========  test: range =========\n");
	test_range(-2, 20, T);
	test_range(-8, 22, T);
	test_range(0, 35, T);
	return 0;
}

运行结果如下图

【注】其实BST的节点还能记录更多的信息，比如深度（depth）或者（height），只要是从应用场景出发设计的合理结构都是可用的；我们还能添加一个count字段，用于处理重复插入相同key节点的问题；同理，目前使用key来排除重复插入的机制，在后续的拓展中可以将这一版BST封装成Set（元素唯一性），这里的讨论回应了本帖开头提出的设想。

5-1-2-7 二分查找的浅显讨论

上一贴讨论的平均深度就是对于随机生成的BST的任意节点的内部路径长度，则可以快速得到BST中的查询时间复杂度就是$O(logN)$；建议大家自己再推导一次，或者参考《算法4》中对应章节的介绍换一个视角去理解这个问题，用不同的符号描述方式去训练一下自己的思维能力。

小结

这篇是在5-1-1和5-2底稿完成后翻看《算法4》及相关文献查缺补漏的结果，个人认为补齐了这块知识点才基本上算吃透了简单BST；目前理论部分的讨论有些单薄，有兴趣的朋友可以去阅读以下《算法导论》和《计算机程序设计艺术》的相关内容给自己加餐；个人建议如最后一小段讨论中建议的那样：既然BST是有序的、可用于二分查找的数据结构，那么现阶段很多讨论就应该围绕着“二分查找”和“排序”两个维度去展开，如此学习收获会更大。

参考文献

[1] 《算法4》
[2] 《黑皮书》