二叉树 及 实现

　　二叉树是数据结构中一种重要的数据结构，也是树表家族最为基础的结构。

　　二叉树的定义：二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^i-1个结点；深度为k的二叉树至多有2^k-1个结点；对任何一棵二叉树T，如果其终端结点数为n₀，度为2的结点数为n₂，则n₀=n₂+1。

　　二叉树的示例：

　　满二叉树和完全二叉树：

　　满二叉树：除最后一层无任何子节点外，每一层上的所有结点都有两个子结点。也可以这样理解，除叶子结点外的所有结点均有两个子结点。节点数达到最大值，所有叶子结点必须在同一层上。

　　满二叉树的性质：

　　1) 一颗树深度为h，最大层数为k，深度与最大层数相同，k=h;

　　2) 叶子数为2^h;

　　3) 第k层的结点数是：2^k-1;

　　4) 总结点数是：2^k-1，且总节点数一定是奇数。

　　完全二叉树：若设二叉树的深度为h，除第 h 层外，其它各层 (1～(h-1)层) 的结点数都达到最大个数，第h层所有的结点都连续集中在最左边，这就是完全二叉树。

　　注：完全二叉树是效率很高的数据结构，堆是一种完全二叉树或者近似完全二叉树，所以效率极高，像十分常用的排序算法、Dijkstra算法、Prim算法等都要用堆才能优化，二叉排序树的效率也要借助平衡性来提高，而平衡性基于完全二叉树。

　　二叉树的性质：

　　1) 在非空二叉树中，第i层的结点总数不超过2^i-1, i>=1;

　　2) 深度为h的二叉树最多有2^h-1个结点(h>=1)，最少有h个结点;

　　3) 对于任意一棵二叉树，如果其叶结点数为N₀，而度数为2的结点总数为N₂，则N₀=N₂+1;

　　4) 具有n个结点的完全二叉树的深度为log₂(n+1);

　　5)有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系：

　　　　若I为结点编号则 如果I>1，则其父结点的编号为I/2；

　　　　如果2I<=N，则其左儿子（即左子树的根结点）的编号为2I；若2I>N，则无左儿子；

　　　　如果2I+1<=N，则其右儿子的结点编号为2I+1；若2I+1>N，则无右儿子。

　　6)给定N个节点，能构成h(N)种不同的二叉树，其中h(N)为卡特兰数的第N项，h(n)=C(2*n, n)/(n+1)。

　　7)设有i个枝点，I为所有枝点的道路长度总和，J为叶的道路长度总和J=I+2ⁱ。

回到顶部

2. 二叉查找树

　　二叉查找树定义：又称为是二叉排序树（Binary Sort Tree）或二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

　　1) 若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

　　2) 若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；

　　3) 左、右子树也分别为二叉排序树；

　　4) 没有键值相等的节点。

　　二叉查找树的性质：对二叉查找树进行中序遍历，即可得到有序的数列。

　　二叉查找树的时间复杂度：它和二分查找一样，插入和查找的时间复杂度均为O(logn)，但是在最坏的情况下仍然会有O(n)的时间复杂度。原因在于插入和删除元素的时候，树没有保持平衡（比如，我们查找上图（b）中的“93”，我们需要进行n次查找操作）。我们追求的是在最坏的情况下仍然有较好的时间复杂度，这就是平衡查找树设计的初衷。

　　二叉查找树的高度决定了二叉查找树的查找效率。

　　二叉查找树的插入过程如下：

　　1) 若当前的二叉查找树为空，则插入的元素为根节点;

　　2) 若插入的元素值小于根节点值，则将元素插入到左子树中;

　　3) 若插入的元素值不小于根节点值，则将元素插入到右子树中。

　　二叉查找树的删除，分三种情况进行处理：

　　1) p为叶子节点，直接删除该节点，再修改其父节点的指针（注意分是根节点和不是根节点），如图a;

　　2) p为单支节点（即只有左子树或右子树）。让p的子树与p的父亲节点相连，删除p即可（注意分是根节点和不是根节点），如图b;

　　3) p的左子树和右子树均不空。找到p的后继y，因为y一定没有左子树，所以可以删除y，并让y的父亲节点成为y的右子树的父亲节点，并用y的值代替p的值；或者方法二是找到p的前驱x，x一定没有右子树，所以可以删除x，并让x的父亲节点成为y的左子树的父亲节点。如图c。

　　二叉树相关实现源码：

　　插入操作：

struct node
{
int val;
 pnode lchild;
 pnode rchild;
};

pnode BT = NULL;


//递归方法插入节点 
pnode insert(pnode root, int x)
{
 pnode p = (pnode)malloc(LEN);
 p->val = x;
 p->lchild = NULL;
 p->rchild = NULL;
if(root == NULL){
 root = p; 
 } 
else if(x < root->val){
 root->lchild = insert(root->lchild, x); 
 }
else{
 root->rchild = insert(root->rchild, x); 
 }
return root;
}

//非递归方法插入节点 
void insert_BST(pnode q, int x)
{
 pnode p = (pnode)malloc(LEN);
 p->val = x;
 p->lchild = NULL;
 p->rchild = NULL;
if(q == NULL){
 BT = p;
return ; 
 } 
while(q->lchild != p && q->rchild != p){
if(x < q->val){
if(q->lchild){
 q = q->lchild; 
 } 
else{
 q->lchild = p;
 } 
 } 
else{
if(q->rchild){
 q = q->rchild; 
 } 
else{
 q->rchild = p; 
 }
 }
 }
return;
}

　　删除操作：

bool delete_BST(pnode p, int x) //返回一个标志，表示是否找到被删元素 
{
bool find = false;
 pnode q;
 p = BT;
while(p && !find){ //寻找被删元素 
if(x == p->val){ //找到被删元素 
 find = true; 
 } 
else if(x < p->val){ //沿左子树找 
 q = p;
 p = p->lchild; 
 }
else{ //沿右子树找 
 q = p;
 p = p->rchild; 
 }
 }
if(p == NULL){ //没找到 
 cout << "没有找到" << x << endl; 
 }

if(p->lchild == NULL && p->rchild == NULL){ //p为叶子节点 
if(p == BT){ //p为根节点 
 BT = NULL; 
 }
else if(q->lchild == p){ 
 q->lchild = NULL;
 } 
else{
 q->rchild = NULL; 
 }
free(p); //释放节点p 
 }
else if(p->lchild == NULL || p->rchild == NULL){ //p为单支子树 
if(p == BT){ //p为根节点 
if(p->lchild == NULL){
 BT = p->rchild; 
 } 
else{
 BT = p->lchild; 
 }
 } 
else{
if(q->lchild == p && p->lchild){ //p是q的左子树且p有左子树 
 q->lchild = p->lchild; //将p的左子树链接到q的左指针上 
 } 
else if(q->lchild == p && p->rchild){
 q->lchild = p->rchild; 
 }
else if(q->rchild == p && p->lchild){
 q->rchild = p->lchild; 
 }
else{
 q->rchild = p->rchild;
 }
 }
free(p);
 }
else{ //p的左右子树均不为空 
 pnode t = p;
 pnode s = p->lchild; //从p的左子节点开始 
while(s->rchild){ //找到p的前驱，即p左子树中值最大的节点 
 t = s; 
 s = s->rchild; 
 }
 p->val = s->val; //把节点s的值赋给p 
if(t == p){
 p->lchild = s->lchild; 
 } 
else{
 t->rchild = s->lchild; 
 }
free(s); 
 }
return find;
}

　　查找操作：

pnode search_BST(pnode p, int x)
{
bool solve = false;
while(p && !solve){
if(x == p->val){
 solve = true; 
 } 
else if(x < p->val){
 p = p->lchild; 
 }
else{
 p = p->rchild; 
 }
 }
if(p == NULL){
 cout << "没有找到" << x << endl; 
 } 
return p;
}