二叉树的建立以及遍历C/C++

一、 二叉树的定义
二叉树（Binary Tree）是个有限元素的集合，该集合或者为空，或者由一个称为根（root）的元素及两个不相交的、分别被称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树，在二叉树中，一个元素也成为一个节点。

二、 二叉树的数据结构
下面为二叉树链式存储结构的定义：

 /* *定义二叉树的数据结构 */typedef char datatype ;typedef struct BiTNode{    datatype data ; //数据域    struct BiTNode *lchild , *rchild ; //孩子的左右节点} BiTNode , *BiTree ;

三、 二叉树的递归遍历
1、 二叉树的前序遍历
若二叉树为非空，则依次进行如下操作：
(1) 访问根节点；
(2) 先序遍历左子树；
(3) 先序遍历右子树；
算法如下：

/* *进行二叉树的先序遍历 */void PreOrder(BiTree bt){    if(bt == NULL) //递归的结束的条件    {        return ;    }    printf("%c " , bt->data) ;    PreOrder(bt->lchild) ;    PreOrder(bt->rchild) ;}

2、 二叉树的中序遍历
若二叉树为非空，则依次进行如下操作：
(1)中序遍历左子树；
(2)访问根节点；
(3)中序遍历右子树；
算法如下：

/* *中序遍历二叉树 */void InOrder(BiTree bt){    if(bt == NULL) //递归的结束条件    {        return ;    }    InOrder(bt->lchild) ;    printf("%c " , bt->data) ;    InOrder(bt->rchild) ;}

3、 二叉树的后续遍历
若二叉树为非空，则依次进行如下操作：
(1)后序遍历左子树；
(2)后序遍历右子树；
(3)访问根节点；
算法如下：

/* *后序遍历二叉树 */void PostOrder(BiTree bt){    if(bt == NULL) //递归的结束条件    {        return ;    }    PostOrder(bt->lchild) ;    PostOrder(bt->rchild) ;    printf("%c " , bt->data) ;}

4、 二叉树的层次遍历
借助队列的数据结构进行层次遍历
(1) 访问当前队头节点；
(2) 若该元素所指节点的左、右孩子节点非空，则将该元素所指节点的左孩子指针和右孩子指针顺序入队；
(3) 此过程不断进行，当队列为空时，二叉树的层次遍历结束；
算法如下：

/* *用队列实现二叉树的层次遍历 */ void LevelOrder(BiTree bt) {     BiTree quene[MAXSIZE] ;     int front , rear ; //分别指向队列的队首语队尾     if(bt == NULL)     {         return ;     }     front = -1 ;     rear = 0 ;     quene[rear] = bt ;     while(front != rear)     {         front++ ;         printf("%c " , quene[front]->data) ;         if(quene[front]->lchild != NULL) //将队首的左孩子节点加入队列         {             rear++;             quene[rear] = quene[front]->lchild ;         }         if(quene[front]->rchild != NULL) //将队首的右孩子节点加入队列         {             rear++;             quene[rear] = quene[front]->rchild ;         }     } }

四、 二叉树的非递归遍历
1、 二叉树的非递归前序遍历
借助栈存储当前访问的节点，栈为空时，访问结束。
算法如下：

/*  *进行二叉树的非递归前序遍历  */void  NRPreOrder(BiTree bt){    BiTree stack[MAXSIZE] , p ;    int i , top ;    if(bt == NULL)    {        printf("二叉树为空！\n") ;        return ;    }    top = 0 ;    p = bt ;    while(p != NULL || top != 0)    {        while(p != NULL)        {            printf("%c " , p->data) ; //范围访问当前元素            if(top < MAXSIZE - 1)            {                stack[top] = p ; //将当前结点压栈                top++ ;            }            else            {                printf("栈溢出！\n") ;                return ;            }            p = p->lchild ; //指针指向该节点的左孩子        }        if(top <= 0)        {            return ;        }        else        {            top-- ;            p = stack[top] ; //从栈中弹出栈顶元素            p = p->rchild ; //指针指向该节点的右孩子        }    }}

2、 二叉树的非递归中序遍历
只需将访问节点的代码移动到p = stack[top] 和 p = p->rchild 之间即可。
算法如下：

/* *进行非递归的中序遍历 */void NRInOrder(BiTree bt){   BiTree stack[MAXSIZE] , p ;    int i , top ;    if(bt == NULL)    {        printf("二叉树为空！\n") ;        return ;    }    top = 0 ;    p = bt ;    while(p != NULL || top != 0)    {        while(p != NULL)        {            if(top < MAXSIZE - 1)            {                stack[top] = p ;                top++ ;            }            else            {                printf("栈溢出！\n") ;                return ;            }            p = p->lchild ;        }        if(top <= 0)        {            return ;        }        else        {            top-- ;            p = stack[top] ;            printf("%c " , p->data) ; //范围访问当前元素            p = p->rchild ;        }    }}

3、 二叉树的后序遍历
在后序遍历过程中，节点在第一次出栈后，还需再次入栈，也就是说节点要入两次栈，出两次栈。而访问节点是在第二次出栈是进行的。因此为了区别节点出栈的次数，定义数据结构：

/* *为二叉树的后续遍历建立数据结构 */typedef struct{    BiTree bt ;    int flag ;} stacktype ;算法如下：/* *进行二叉树的后序遍历 */void NRPostOrder(BiTree bt){    stacktype stack[MAXSIZE] ;    int top , sign ;    BiTree p ;    if(bt == NULL)    {        return ;    }    top = -1 ;    p = bt ;    while(p != NULL || top != -1)    {        if(p != NULL)        {            top++ ;            stack[top].bt = p ;            stack[top].flag = 1;            p = p->lchild ;        }        else        {            p = stack[top].bt ;            sign = stack[top].flag ;            top-- ;            if(sign == 1)            {                //进行二次压栈                top++ ;                stack[top].bt = p ;                stack[top].flag = 2 ;                p = p->rchild ;            }            else            {                printf("%c " , p->data) ; //进行二叉树的访问                p = NULL ;            }        }    }}

五、 二叉树的建立
由二叉树的性质可知，二叉树可有先序序列和中序序列唯一确定，而后序序列与中序序列无法确定唯一二叉树。
算法思想是：运用递归求解二叉树，先根据先序序列的第一个元素建立根节点；然后在中序序列中找到该元素，确定根节点的左、右子树的中序序列；再在先序序列中确定左、右子树的先序序列；最后由左子树的先序序列与中序序列建立左子树，由右子树的先序序列与中序序列建立右子树。
算法如下：

void PreInO(char preOrder[] , char inOrder[] , int i , int j , int k , int h , BiTree *bt){    int m ;    if(!((*bt) = (BiTree)malloc(sizeof(BiTNode))))    {        return ;    }    else    {       (*bt)->data = preOrder[i] ;        m = k ;        while(preOrder[i] != inOrder[m])        {            m++ ;        }        if(m == k)        {            (*bt)->lchild = NULL ;        }        else        {            PreInO(preOrder , inOrder , i + 1 , m - k + i , k , m - 1 , &((*bt)->lchild)) ; //进行左子树的建立        }        if(m == h)        {            (*bt)->rchild = NULL ;        }        else        {            PreInO(preOrder , inOrder , m - k + i + 1 , j , m + 1 , h , &((*bt)->rchild)) ; //进行右子树的建立        }    }}/* *根据二叉树的前序遍历序列和中序遍历确定唯一二叉树 *根据二叉树的中序遍历和后续遍历不能确定唯一二叉树 */void ReBiTree(char preOrder[] , char inOrder[] , BiTree *bt){    int len ;    len = strlen(preOrder) ;    if(len <= 0)    {        return ;    }    else    {        PreInO(preOrder , inOrder , 0 , len - 1 , 0 , len - 1 , bt) ;    }}