[数据结构]——二叉树（Binary Tree）、二叉搜索树（Binary Search Tree）及其衍生算法

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

二叉树（Binary Tree）是最简单的树形数据结构，然而却十分精妙。其衍生出各种算法，以致于占据了数据结构的半壁江山。STL中大名顶顶的关联容器——集合（set）、映射（map）便是使用二叉树实现。由于篇幅有限，此处仅作一般介绍（如果想要完全了解二叉树以及其衍生出的各种算法，恐怕要写8~10篇）。

1）二叉树（Binary Tree）

顾名思义，就是一个节点分出两个节点，称其为左右子节点；每个子节点又可以分出两个子节点，这样递归分叉，其形状很像一颗倒着的树。二叉树限制了每个节点最多有两个子节点，没有子节点的节点称为叶子。二叉树引导出很多名词概念，这里先不做系统介绍，遇到时再结合例子一一说明。如下一个二叉树：

/* A simple binary tree
* A ---------> A is root node
* / \
* / \
* B C
* / / \
* / / \
* D E F ---> leaves: D, E, F
*
* (1) ---> Height: 3
* */

其中节点B只有一个子节点D；D, E, F没有子节点，被称为叶子。对于节点C来说，其分出两子节点，所以C的出度为2；同理，C有且只有一个父节点，所以其入度为1。出度、入度的概念来源于图（Graph，一种更加高级复杂的数据结构），当然，也可以应用于二叉树（二叉树或者说树形数据结构也是一类特殊的图）。显然，二叉树的根节点入度为0，叶子节点出度为0。

如何衡量一颗二叉树？比如大小、节点稠密等。与楼房一样，一般会对二叉树分层，并且通常将根节点视为第一层。接下来B与C同属第二层，D, E, F同属第三层。注意，并不是所有的叶子都在同一层。通常将二叉树节点的最高层数作为其树的高度，上例中二叉树高度为3。显然，一个二叉树的节点总数必然小于2的树高幂，转化成公式表示为：N<2^H，其中N为节点总数，H为二叉树高度；对于第k层，最多有2^(k-1)个节点。更加细化的分类，如下：

完全二叉树：除了最高层以外，其余层节点个数都达到最大值，并且最高层节点都优先集中在最左边。

满二叉树：除了最高层有叶子节点，其余层无叶子，并且非叶子节点都有2个子节点。

如下例：

/* Complete Binary Tree (CBT) and Full Binary Tree (FBT)
* A A A
* / \ / \ / \
* / \ / \ / \
* B C B C B C
* / \ / \ / \ / \
* / \ / \ / \ / \
* D E D E F G D E
*
* (2) (3) (4)
* CBT FBT not CBT
* */

其中(2)就是一个完全二叉树；(3)是一个满二叉树；而(1)和(4)不属于这两者，（虽然(4)是(2)的一种镜像二叉树）。易知，满二叉树必然是一个完全二叉树，反之则不然。从节点数量上看，满二叉树的第k层有2^(k-1)个节点，所以其总节点数为2^H - 1；完全二叉树除了最后一层外，第k层节点有2^(k-1)个节点，最后一层最多有2^(H-1)个节点。

其实，关于完全二叉树的定义有多种，然而不管怎样定义，其实质是一样的，关键在于怎样理解。如果完全二叉树除去最后一层，则成为一个满二叉树。所谓的“最后一层节点优先集中在左边”，用语言很难解释，但是结合上例的(2)和(4)可以很好理解。为什么要这样定义呢？这是因为这种完全二叉树的效率非常高，并且完全二叉树绝大多数情况使用数组存储，即无序堆（Heap）！可以参见关于堆的博文http://www.cnblogs.com/eudiwffe/p/6202111.html为了充分利用数组的存储空间，优先将叶子安排在最左边，以保证该数组每个存储单元都被利用（如果是(4)的情况，则该数组会有部分空间浪费）。这就是为什么要要求“最后一层优先集中在最左边”。

2）二叉树的构建和遍历

数据结构和算法，最终要落实在代码上，首先给出一般C风格的二叉树节点定义，其中val在同一颗树中唯一：

// A simple binary tree node define
typedef struct __TreeNode
{
int val;
struct __TreeNode *left, *right;
}TreeNode;

很简单，看着很像双链表节点的定义，如果抛开字段名称，其实质完全跟双链表节点结构一样。事实上，有很多情况下需要将二叉树就地转换成一个双链表，甚至是单链表。如何构建一个二叉树？很抱歉，这个占据数据结构与算法半壁江山的二叉树，竟然没有一个标准的构建方法！因为二叉树使用太过广泛，针对不同应用有不同的构建方法，如果仅仅将一个节点插入（或删除）到二叉树中，这又太过简单，简单的与链表插入（或删除）一样。故本文不提供构建方法。

对于给定的一颗二叉树，如何遍历呢？有四种常见方法。

中序遍历：即左-根-右遍历，对于给定的二叉树根，寻找其左子树；对于其左子树的根，再去寻找其左子树；递归遍历，直到寻找最左边的节点i，其必然为叶子，然后遍历i的父节点，再遍历i的兄弟节点。随着递归的逐渐出栈，最终完成遍历。例如(1)中的遍历结果为：D->B->A->E->C->F

先序遍历：即根-左-右遍历，不再详述。例如(1)中的遍历结果：A->B->D->C->E->F

后序遍历：即左-右-根遍历，不再详述。例如(1)中的遍历结果：D->B->E->F->C->A

层序遍历：即从第一层开始，逐层遍历，每层遍历按照从左到右遍历。例如(1)中的遍历结果：A->B->C->D->E->F

很明显，先序遍历的第一个节点必然是树的根节点；后序遍历的最后一个节点也必然是树的根节点。层序遍历更加符合人对二叉树的树形结构的遍历顺序。

下面给出一般的实现代码供参考：

// root is in middle order travel, (1):D->B->A->E->C->F
void inorder(TreeNode *root)
{
if (root == NULL) return;
inorder(root->left);
printf("%d ",root->val);// visit
inorder(root->right);
}
// previous visit root order travel, (1):A->B->D->C->E->F
void preorder(TreeNode *root)
{
if (root == NULL) return;
printf("%d ",root->val);// visit
preorder(root->left);
preorder(root)
}
// post vist root order travel, (1):D->B->E->F->C->A
void postorder(TreeNode *root)
{
if (root == NULL) return;
postorder(root->left);
postorder(root->right);
printf("%d ",root->val);// visit
}

看着很简单感觉不太对，毋庸置疑，事实上就是这么简单。此处仅给出递归版本，虽然递归间接用到了栈，但是即便使用循环版本实现，其仍然需要辅助空间存储。为什么在实现堆的代码中，用的是循环而不是递归？这就是因为堆的形象化是一个完全二叉树，并且用数组存储，可见完全二叉树的效率如此之高。对于层序遍历，就需要使用辅助的存储空间，一般使用队列（queue），因为其要求每层的顺序要从左到右。下面使用STL中queue进行实现，关于队列的介绍，请自行补充。

// level order travel, (1):A->B->C->D->E->F
void levelorder(TreeNode *root)
{
if(root==NULL) return;
queue<TreeNode*> q;
for(q.push(root); q.size(); q.pop()){
TreeNode *r = q.front();
printf("%d ",r->val);// visit
if (r->left) q.push(r->left);
if (r->right) q.push(r->right);
}
}

上面是一种层序遍历，但并没有对每层进行分割，换言之，并不知道当前遍历的节点属于哪一层。如需实现，只需要两个队列交替遍历，每个队列遍历完就是一层的结束，感兴趣的可以自行写出。

其中，前面三种遍历最为常见，先序遍历是二叉树的深度优先遍历（Depth First Search，DFS），使用最广泛。层序遍历是二叉树的广度优先遍历（Breadth First Search，BFS）。

3）二叉树的序列化（serialize）和反序列化（deserialize）

简单讲，序列化就是将结构化数据转化成可顺序传输的数据流；反序列化就是将顺序数据流还原成原来的数据结构。

前面几种遍历方法，虽然都可以将二叉树转换成顺序的数据流，但还不能称作序列化，因为没有办法还原二叉树结构。以(1)为例，其常见四种遍历方法得到的数据流为：

/* A simple binary tree four typical traversals
* A
* / \ in order : D->B->A->E->C->F
* / \ pre order : A->B->D->C->E->F
* B C post order : D->B->E->F->C->A
* / / \ level order: A->B->C->D->E->F
* / / \
* D E F
*
* (1)
* */

单独使用无法将其还原成二叉树。但是，仔细观察发现，先序遍历的第一个节点A为根节点；后序遍历的最后一个节点A也是根节点。如果同时知道一个二叉树的先序和后序遍历顺序，是否可以还原树呢？很抱歉，虽然两种遍历的方法不一样，但其只能确定根节点的位置，其他节点无法确定。那么，如果使用中序+先序遍历结果，是否可行呢？让我们试试。

根据先序遍历知道第一个节点A为根节点，接下来“B->D->C->E->F”是左右节点的顺序，虽然目前还无法判断到底哪个是左，哪个是右；

前面已知，中序遍历以根节点为分隔，左边是左子树，右边是右子树，于是在中序中找到A的位置，以此分隔，左部分“D->B”是左子树，右部分“E->C->F”是右子树；

请注意，对于任意一个节点来说，都是某个子树的根节点，即便是叶子节点，它也是一个空二叉树的根节点！由此引出，先序遍历的每个节点都曾充当父节点（某子树的根节点）。

于是，对于剩下的先序遍历数据流“B->D->C->E->F”来说，B也是剩下的某子树的根节点，究竟是哪个子树呢？显然是左子树，因为先序遍历的顺序就是“根-左-右”。因此，在左子树“D->B”中找到B，其为左子树的根；于是将“D->B”分成左子树“D”和右子树“”（空）。根据递归的出栈，接下来处理先序遍历中的“D->C->E->F”，紧接着是“C->E->F”...最终，完成二叉树的还原。部分步骤示意图：

// Using In order and Pre order to deserialize
/*
* A* A A A
* / \ ====> / \ / \ / \
* / \ / \ / \ / \
* D-B E-C-F B* E-C-F B E-C-F B C*
* / \ / / / \
* / \ / / / \
* D NULL D* D E F
* root root root root
* | | | |
* IN: D-B-A-E-C-F D-B D E-C-F
* PRE:A-B-D-C-E-F B-D-C-E-F D-C-E-F C-E-F
* | | | |
* root root root root
* */

每次根据先序遍历结果确定当前的根节点（用*标记），然后在中序遍历结果中寻找该节点，并以此为分割点，分成左右子树；反复执行，直到先序遍历结束，二叉树还原完毕。下面给出C风格的代码，仅供参考：

// Using In order and Pre order to deserialize
TreeNode *deserialize(int pre[], int in[], int n, int begin, int end)
{
static int id = 0;// current position in PRE order
if (begin==0 && end==n) id=0;// reset id
TreeNode *r = (TreeNode*)malloc(sizeof(TreeNode));
int pos;// current root position in IN order
for (pos=begin; pos<end && in[pos]!=pre[id]; ++pos);
if (in[pos]!=pre[id]) exit(-1);// preorder or inorder is error
r->val = pre[id++];
r->left = deserialize(pre,in,n,begin,pos);
r->right= deserialize(pre,in,n,pos+1,end);
return r;
}

其中pre[]为先序遍历结果，in[]为中序遍历结果，此处假设节点的值(val)为唯一（对于不唯一的，可以增加关键字字段）。n为节点总数，也即为数组的长度；start和end表示寻找中序遍历的区间范围[start,end)。如果给定的pre[]和in[]绝对正确，那么第9行的错误处理将不会执行。对于一棵N节点的二叉树，直接调用deserialize(pre,in,n,0,n)则可还原该二叉树。整个逆序列化的过程，实际上是“先序遍历”的过程，不妨看看10~12行代码。

同理，使用中序+后序也可还原二叉树，这里不再详述。

不妨算法其时间复杂度，对于先序数据流，其使用了静态的id作为遍历下标，故为O(n)；但是对于中序遍历数据流，其根据[start,end)区间进行遍历寻找，为O(nlogn)。感兴趣的不妨尝试改进层序遍历，使其达到序列化和反序列化的要求（注意分层和空节点）。

4）二叉搜索树（Binary Search Tree）

之所以称为二叉搜索树，是因为这种二叉树能大幅度提高搜索效率。如果一个二叉树满足：对于任意一个节点，其值不小于左子树的任何节点，且不大于右子树的任何节点（反之亦可），则为二叉搜索树。如果按照中序遍历，其遍历结果是一个有序序列。因此，二叉搜索树又称为二叉排序树。不同于最大堆（或最小堆），其只要求当前节点与当前节点的左右子节点满足一定关系。下面以非降序二叉搜索树为例。

// Asuming each node value is not equal
/* A simple binary search tree
* 6 6
* / \ / \
* / \ / \
* 3 8 3 8
* / / \ / / \
* / / \ / / \
* 2 7 9 2 4* 9
*
* (A) BST (B) Not BST
* */

其中（A）为二叉搜索树，（B）不是。因为根节点6小于右子树中的节点4。

构建二叉搜索树的过程，与堆的构建类似，即逐渐向二叉搜索树种添加一个节点。每次新添加一个节点，直接寻找到对应的插入点，使其满足二叉搜索树的性质。下面是一种简易的构建过程：

// Initialize a bst
TreeNode *bst_init(int arr[], int n)
{
if (n<1) return NULL;
TreeNode *r = (TreeNode*)malloc(sizeof(TreeNode));
r->val = arr[0];// ensure bst_append will not update root address
r->left = r->right = NULL;
for (; --n; bst_append(r,arr[n]));
return r;
}

对于给定的数组数据，如果仅有一个元素，则直接构造一个节点，将其返回；否则，逐渐遍历该数组，将其元素插入到二叉树中（不要忘记将无子节点的指针置为空），其中bst_append将元素插入的二叉查找树中。为什么对于单独一个元素要特殊处理，而不是所有节点都通过bst_append插入呢？显然，当插入第一个元素时，此时二叉树根节点为空，直接插入必然修改根节点的地址。当然可以通过返回值获取插入后二叉树的根节点指针，但这样仅仅针对1/n的情况，却每次（共N次）都重新对根节点赋值，牺牲太多性能。当然也可以将bst_append传参列表声明为二级指针，这里为了追求简洁，故不使用。

当给出插入节点的代码时，你会发现二叉搜索树的构建跟堆的构建思路有异曲同工之妙，并且插入方法与先序遍历十分相似：

// Append a node to bst, return add count
int bst_append(TreeNode *r, int val)
{
// find insertion position
for (; r && r->val!=val;){
if (r->val < val && r->right) r=r->right;
else if (r->val > val && r->left) r=r->left;
else break;
}
if (r==NULL || r->val==val) return 0;
TreeNode *tn = (TreeNode*)malloc(sizeof(TreeNode));
tn->left = tn->right = NULLL;
tn->val = val;
if (r->val < val) r->right = tn;
else r->left = tn;
return 1;
}

通常情况，认为二叉树的节点值为唯一，即不存在新插入的值与已有节点值相同的情况，正如一个集合中不存在相同的两个元素。虽然STL也提供multiset与multimap以便允许重复元素，但其增加了新的字段count用于存储每个值val所包含的节点个数。易知，对于set而言，其每个节点的count值均为1。注意，对于同一个元素集合，其数组中的顺序不同，生成的二叉查找树也不同。其中，二叉搜索树的插入时间复杂度为O(logn)，构建二叉搜索树的总时间复杂度为O(nlogn)。寻找插入位置的过程，实际上类似于二分查找。

既然叫二叉搜索树，那么如何高效的查找一个元素是否在该二叉搜索树呢？与插入类似，同样使用先序遍历的结构：

// Find value in bst, return node address
TreeNode *bst_find(TreeNode *r, int val)
{
for (; r && r->val!=val;){
if (r->val < val) r=r->right;
else if (r->val > val) r=r->left;
}
return r;
}

如果找到了，直接返回该节点指针，否则返回空指针。二叉搜索树对于元素的查找效率与二分查找一样，都为O(logn)，只不过前者使用二叉树链式存储，而二分查找使用顺序的数组存储，两者各有优劣。

很多时候，常常需要删除其中的某些元素，对于二分查找来说，其使用的是有序数组存储，对于数据的插入和删除效率较低，均为O(n)；而二叉搜索树却有着O(logn)的快速，那么如何删除节点？与堆不同，二叉搜索树使用链式存储，需要注意内存释放，避免其父节点、左右子节点意外分离于原二叉搜索树。因此需要根据待删除节点所处位置，进行分类处理。

在这之前，首先引入一个概念——前驱节点（Precursor Node）。所谓前驱，即按照某种遍历方法，节点前的一个节点为该节点的前驱节点。以（1）为例，其中序遍历为“D->B->A->E->C->F”，那么对于节点A来说，其前驱节点为B；对于节点E来说，A是其前驱节点（下面不作特殊说明，均以中序遍历顺序情况）。与之相反，后继节点则为按照某种遍历方法该节点的下一个节点。即，A是B的后继节点。对于二叉搜索树来讲，如果使用中序遍历，其遍历结果是有序的，即：任意一个节点的前驱节点是满足不大于该节点的最大节点；任意一个节点的后继节点是满足不小于该节点的最小节点。以（A）为例，其中序遍历为“2-3-6-7-8-9”。

对于二叉搜索树的节点删除，一般可分为三种情况：待删除的节点有两个子节点，待删除的节点有一个子节点，待删除的节点无子节点：

/* Erase node from a bst - sketch, i' is special for erase 6 (i)
* 6 d=6,(3) f=6 6 d=6,(5)
* / \ / \ / \ / \ / \
* / \ / \ / \ / \ / \
* 3 8 p=3 8 d=3 8 3 f=8 f=3 8
* / / \ / / \ / / \ / / \ / \ / \
* / / \ / / \ / / \ / / \ / \ / \
* 2 7 9 2 7 9 2 7 9 2 d=7 9 2 p=5 7 9
* /
* BST (i) (ii) (iii) / (i')
* erase 6 erase 3 erase 7 4
* */

(i) 待删除的节点有两个子节点：以删除6为例，为了便于说明，这里将待删除节点称为d=6，其前驱节点为p=3。按照(i)图示方法，可以将其前驱节点p的值替换待删除节点d，并删除前驱节点。注意，如果前驱节点p仍有子节点（子树），则其必然是左节点（左子树），为什么？请自行思考。这里将前驱节点p的父节点称为f，此时的f正好是d，但不是所有情况都是。对于(i')图示，前驱节点p=5的父节点为f=3，当删除d=6时，可以将f的右子节点指向p的左子节点；对于(i)，由于f与d相同，所以可以直接将d的左子节点指向p的左子节点。

(ii)待删除的节点有一个子节点：以删除3为例，由于只有一个子节点，所以可将d节点的子节点继承d，此时需要将d的父节点f=6的子节点指向继承节点。并且需要区分当前删除节点d是父节点f的左子节点还是右子节点，以及d节点的子节点是左子还是右子。图示d为f的左子节点，d有左子节点，所以将f的左子节点指向d的左子节点。

(iii)待删除的节点无子节点：以删除7为例，很简单，将其直接删除，并且将其父节点f的子节点指向空。同样需要判断d是f的左子还是右子。

请注意，对于单根二叉树，即一个二叉搜索树有且只有一个节点，此时需要删除该根节点，那么删除根节点后，二叉树为空。与bst_append类似，如果为空，需要通过返回值回传根节点为空，或者通过传参列表声明二级节点指针。为了简化代码，此处不对其进行处理，由调用删除节点处自行处理。

下面是一种实现代码，其中返回值表示删除的节点个数，对于单根二叉树返回-1，告诉调用者，并由调用者自行处理：

int bst_erase(TreeNode *r, int val)
{
TreeNode *f, *p, *d;
// f is father node
// p is precursor node
// d is to be deleted node
for (f=NULL,d=r; d && d->val!=val;){
f = d;
if (d->val < val) d=d->right;
else d=d->left;
}
if (d==NULL) return 0;// cannot find erase nodeif (d->left && d->right){// deletion has two children
// find deletion node d's precursor
for (f=d,p=d->left; p->right; f=p, p=p->right);
d->val = p->val;// replace deletion val by precursor
if (f==d) d->left = p->left;// case (i)
else f->right = p->left;// case (i')
}
else if (d->left==NULL && d->right==NULL){
if (d==r) return -1;// deletion is single root, this will
// replace root address to NULL, please
// deal this at calling procedure.
// deletion is leaf
if (f->left == d) f->left=NULL;
else if (f->right == d) f->right=NULL;
free(d);
}
else {// deletion has single child node or branch
p = (d->left ? d->left : d->right);
d->val = p->val;
d->left = p->left;
d->right = p->right;
free(p);
}
return 1;// return erase node count
}