二叉树

二叉树（Binary Tree）：每个结点至多只有两颗子树（即二叉树中不存在度大于2的结点），并且，二叉树的子树有左右之分，其次序不能任意颠倒。
二叉树性质：
（1） 在二叉树的第i层上至多有个结点。
（2） 深度为k的二叉树至多有个结点。
（3） 对任何一颗二叉树T，如果其终端结点数为，度为2的结点数为，则。
（4） 具有n个结点的完全二叉树的深度为
（5） 如果对一颗树有n个结点的完全二叉树（其深度）的结点按层序编号（从第一层到第层，每层从左到右），则对任一结点i（1<=i<=n），有
1） 若i=1，则结点i是二叉树的根，无双亲；如果i>1，则双亲PARENT(i)是结点。
2） 若2i>n，则结点i无左孩子（结点i为叶子结点）；否则其左孩子LCHILD(i)是结点2i。
3） 若2i+1>n，则结点i无右孩子；否则其右孩子LCHILD(i)是结点2i+1。
（6） 给定n个结点，能构成h(n)=C(2n,n)/(n+1)种不同的二叉树。即为卡特兰数的第n项，catalan 数h(0)=1,h(1)=1…（n>=0）。
注：1.树（Tree）：是n（n>=0）个结点的有限集。在任意一颗非空树中：（1）有且仅有一个特定的称为根（Root）的结点；（2）当n>1时，其余结点可分为m（m>0）个互不相交的有限集T1，T2，… Tm，其中每一个集合本身又是一颗树，并且称为根的子树（SubTree）。2.满二叉树：一颗深度为K且有个结点。3.完全二叉树：深度为k的，有n个结点的二叉树，当且仅当其每个结点都与深度为k的满二叉树中编号从1至n个结点一一对应。4.赫夫曼（Huffman）树：又称最优树，是带权路径长度WPL最小的二叉树。路径长度：从树中一个结点到另一个结点之间的分支构成这两个点之间的路径；路径上的分支数目。树的带权路径长度：树中所有叶子结点的带权路径长度之和；记作。5.二叉排序树（Binary Sort Tree）：又称二叉查找树；1）若它的左子树不空，则左子树上所有节点值均小于它的根结点的值；2）若它的右子树不空，则右子树上所有节点值均大于它的根结点的值；3）它的左、右子树也分别为二叉排序树。6.平衡二叉树（Balanced Binary Tree/Height-Balanced Tree）：它的左子树和右子树都是平衡二叉树；且左子树和右子树的深度之差的绝对值不超过1。红黑树（Red Black Tree）：是一种自平衡二叉查找树。都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。7.存储结构：1）顺序存储结构：用一组地址连续的存储单元依次自上而下、自左至右存储完全二叉树上的结点元素，即将完全二叉树上编号为i的结点元素存储在一维数组中下标为i-1的分量中。2）链式存储结构：二叉链表由数据域和左、右指针域；在含有n个结点的二叉链表中有n+1个空链域。三叉链表由数据域和左、右指针域及指向其双向亲的指针域。8.遍历二叉树（traversing binary tree）：如何按某条搜索路径巡访树中每个结点，使每个结点均被访问一次，而且仅被访问一次。实质上是：对一个非线性结构进行线性化操作，使每个结点在这些线性序列中有且仅有一个直接前驱和直接后继。1）先序遍历（preOrderTraverse）：访问根节点；先序遍历左子树；先序遍历右子树。2）中序遍历（inOrderTraverse）：中序遍历左子树；访问根结点；中序遍历右子树。3）后序遍历（postOrderTraverse）：后序遍历左子树，后序遍历右子树；访问根结点。4）层序遍历（levelOrderTraverse）：从上到下、从左到右按层次进行。9.线索二叉树：若结点有左子树，则其lchild域指示其左孩子，否则令lchild域指示其前驱；若结点有右子树，则其rchild域指示其右孩子，否则令rchild域指示其后继。其中指向结点前驱和后继的指针叫做线索。对二叉树以某种次序遍历使其变为线索二叉树的过程叫做线索化。

---

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <stack>
#include <queue>
using namespacestd;

//二叉树的二叉链表存储表示
typedef structbiTNode{
         chardata;
         structbiTNode *lchild, *rchild;
}biTNode, *biTree;

/*
*createBiTree
*函数功能：按先序次序输入二叉树中的结点值,#字符表示空树
*输入：二叉树的根结点root
*返回值：二叉树根结点root
*/
biTree createBiTree(biTree &root){
         chardata;
         cout<< "输入一个字符：" << endl;
         cin>> data;
         if(data =='#')
                   root= NULL;
         else{
                   root= (biTree)malloc(sizeof(biTNode));
                   root->data= data;
                   createBiTree(root->lchild);
                   createBiTree(root->rchild);
         }
         returnroot;
}
/*
*preOrderTraverse
*函数功能：先序遍历二叉树的递归算法
*输入：二叉树的根结点root
*返回值：void
*/
void preOrderTraverse(biTreeroot){
         if(root){
                   cout<< root->data << endl;
                   preOrderTraverse(root->lchild);
                   preOrderTraverse(root->rchild);
         }
}
/*
*inOrderTraverse
*函数功能：中序遍历二叉树的递归算法
*输入：二叉树的根结点root
*返回值：void
*/
void inOrderTraverse(biTreeroot){
         if(root){
                   inOrderTraverse(root->lchild);
                   cout<< root->data << endl;
                   inOrderTraverse(root->rchild);
         }
}
/*
*postOrderTraverse
*函数功能：后序遍历二叉树的递归算法
*输入：二叉树的根结点root
*返回值：void
*/
void postOrderTraverse(biTreeroot){
         if(root){
                   postOrderTraverse(root->lchild);
                   postOrderTraverse(root->rchild);
                   cout<< root->data << endl;
         }
}
/*
*preOrderTraverse2
*函数功能：先序遍历二叉树的非递归算法
*输入：二叉树的根结点root
*返回值：void
*/
void preOrderTraverse2(biTreeroot){
         stack<biTree> s;
         biTree p = root;
         while(p || !s.empty()){
                   if(p){ //根指针进栈，访问根结点，遍历左子树
                            s.push(p);
                            cout<< p->data << endl;
                            p= p->lchild;
                   }
                   else{//根指针推栈，遍历右子树
                            p= s.top();
                            s.pop();
                            p= p->rchild;
                   }
         }
}
/*
*inOrderTraverse2
*函数功能：中序遍历二叉树的非递归算法
*输入：二叉树的根结点root
*返回值：void
*/
void inOrderTraverse2(biTreeroot){
         stack<biTree> s;
         biTree p = root;
         while(p||!s.empty()){
                   if(p){ //根指针进栈，遍历左子树
                            s.push(p);
                            p= p->lchild;
                   }
                   else{//根指针推栈，访问根结点，遍历右子树
                            p= s.top();
                            cout<<p->data<< endl;
                            s.pop();
                            p= p->rchild;
                   }
         }
}
/*
*postOrderTraverse2
*函数功能：后序遍历二叉树的非递归算法
*输入：二叉树的根结点root
*返回值：void
*/
void postOrderTraverse2(biTreeroot){
         stack <biTree> s;
         biTree cur; //当前结点
         biTree pre = NULL; //前一次访问的结点
         s.push(root);
         while(!s.empty()){
                   cur= s.top();
                   if((cur->lchild==NULL&&cur->rchild==NULL)||
                            (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild))){ //如当前结点没有孩子结点或者孩子结点都已经被访问
                            cout<< cur->data << endl;
                            s.pop();
                            pre= cur;
                   }
                   else{
                            if(cur->rchild)
                                     s.push(cur->rchild);
                            if(cur->lchild)
                                     s.push(cur->lchild);
                   }
         }
}
/*
*levelOrderTraverse
*函数功能：由于其层级的关系，很明显要用到队列来辅助实现，
*          主要是从左向右，自上而下，依次将二叉树的各节点入队，
*          这样便可以保证输出的顺序是层序排列的。
*输入：二叉树的根结点
*返回值：void
*/
void levelOrderTraverse(biTreeroot){
         if(root){
                   queue<biTree> q;
                   biTree p;
                   q.push(root);
                   while(!q.empty()){
                            p= q.front();
                            cout<< p->data << endl;
                            q.pop();
                            if(p->lchild)
                                     q.push(p->lchild);
                            if(p->rchild)
                                     q.push(p->rchild);
                   }
         }
}

/*
*depthOfBiTree
*函数功能：递归求树的深度
*输入：二叉树的根结点root
*返回值：二叉树的深度
*/
int depthOfBiTree(biTreeroot){
         intldepth = 0;
         intrdepth = 0;
         if(root==NULL)
                   return0;
         ldepth= depthOfBiTree(root->lchild);
         rdepth= depthOfBiTree(root->rchild);
         return(ldepth >=rdepth) ? (ldepth + 1) : (rdepth + 1);
}
/*
*leafCountOfBiTree
*函数功能：递归求二叉树的叶子结点个数
*输入：二叉树的根结点
*返回值：二叉树的叶子个数
*/
int leafCountOfBiTree(biTreeroot){
         if(root==NULL)
                   return0;
         if(root->lchild==NULL&&root->rchild==NULL)
                   return1;
         returnleafCountOfBiTree(root->lchild) + leafCountOfBiTree(root->rchild);
}
/*
*invertBiTree
*函数功能：递归实现反向二叉树
*输入：二叉树的根结点root
*返回值：void
*/
void invertBiTree(biTreeroot){
         if(root==NULL)
                   return;
         biTree node =root->lchild;
         root->lchild= root->rchild;
         root->rchild= node;
         invertBiTree(root->lchild);
         invertBiTree(root->rchild);
}
/*
*invertBiTree2
*函数功能：非递归实现反向二叉树
*输入：二叉树的根结点root
*返回值：void
*/
void invertBiTree2(biTreeroot){
         stack <biTree> s;
         s.push(root);
         while(!s.empty()){
                   biTree top = s.top();
                   s.pop();
                   biTree temp = top->lchild;
                   top->lchild= top->rchild;
                   top->rchild= temp;
                   if(top->lchild)
                            s.push(top->lchild);
                   if(top->rchild)
                            s.push(top->rchild);
         }
}