二叉树

参考博客

浅谈数据结构-二叉树
二叉树的好处（应用）
用递归方法建立二叉树
数据结构（六）——二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现
Java中二叉树存储结构实现
二叉树的好处（应用）
二叉树可以解决什么问题
二叉树（binary tree）-重要性

目录

• 特点
• 特殊二叉树及其特点
• 二叉树性质
• 二叉树遍历
• 二叉树建立
• 二叉树作用

特点

二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”和“右子树”，左子树和右子树同时也是二叉树。二叉树的子树有左右之分，并且次序不能任意颠倒。二叉树是递归定义的，所以一般二叉树的相关题目也都可以使用递归的思想来解决，当然也有一些可以使用非递归的思想解决

特殊二叉树

• 斜树
• 满二叉树
• 完全二叉树

斜树
所有的结点都只有左子树（左斜树），或者只有右子树（右斜树）。这就是斜树，应用较少

满二叉树
所有的分支结点都存在左子树和右子树，并且所有的叶子结点都在同一层上，这样就是满二叉树。就是完美圆满的意思，关键在于树的平衡。
根据满二叉树的定义，得到其特点为：

1. 叶子只能出现在最下一层。
2. 非叶子结点度一定是
3. 在同样深度的二叉树中，满二叉树的结点个数最多，叶子树最多。

完全二叉树
对一棵具有n个结点的二叉树按层序排号，如果编号为i的结点与同样深度的满二叉树编号为i结点在二叉树中位置完全相同，就是完全二叉树。满二叉树必须是完全二叉树，反过来不一定成立。

特点：

1. 叶子结点只能出现在最下一层（满二叉树继承而来）
2. 最下层叶子结点一定集中在左 部连续位置。
3. 倒数第二层，如有叶子节点，一定出现在右部连续位置。
4. 同样结点树的二叉树，完全二叉树的深度最小（满二叉树也是对的）。

二叉树的遍历

二叉树遍历：从树的根节点出发，按照某种次序依次访问二叉树中所有的结点，使得每个结点被访问仅且一次。

• 前序遍历
  
  基本思想：先访问根结点，再先序遍历左子树，最后再先序遍历右子树即根—左—右。

前序递归遍历
//前序递归遍历
void PreOrderTraverse(BiTree t)
{
//注意跳出条件
if(t != NULL)
{
//注意访问语句顺序
printf("%c ", t->data);
PreOrderTraverse(t->lchild);
PreOrderTraverse(t->rchild);
}
}
前序非递归遍历
a. 访问结点p，并将结点p入栈；
b. 判断结点p的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点p，循环置a；若不为空，则将p的左孩子置为当前结点p；
c. 直到p为空，并且栈为空，则遍历结束。

//前序非递归遍历
int NoPreOrderTraverse(BiTree t)
{
    SqStack s;
    InitStack(&s);

    BiTree tmp = t;
    if(tmp == NULL)
    {
        fprintf(stdout, "the tree is null.\n");
        return ERROR;
    }
   //现将左子树压入栈，当到叶子结点后，出栈，获取右子树，然后在压入右子树的左子树。
  //顺序不能变
    while((tmp != NULL) || (IsEmpty(&s) != 1)) 
    {
        while(tmp != NULL)
        {
            Push(&s, tmp);
            printf("%c ", tmp->data);
            tmp = tmp->lchild;
        }
        if(IsEmpty(&s) != 1)
        {
            Pop(&s, &tmp);
            tmp = tmp->rchild;
        }
    }

    return OK;
}

• 中序遍历
  
  基本思想：先中序遍历左子树，然后再访问根结点，最后再中序遍历右子树即左—根—右。

中序遍历迭代

//中序递归遍历
void InOrderTraverse(BiTree t)
{
    if(t != NULL)
    {
        InOrderTraverse(t->lchild);
        printf("%c ", t->data);
        InOrderTraverse(t->rchild);
    }
}

中序非递归遍历
a. 若其左孩子不为空，则将p入栈，并将p的左孩子设置为当前的p，然后对当前结点再进行相同的操作；
b. 若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的p置为栈顶结点的右孩子；
c. 直到p为空并且栈为空，则遍历结束。

//中序非递归遍历二叉树
int NoInOrderTraverse(BiTree t)
{
    SqStack s;
    InitStack(&s);

    BiTree tmp = t;
    if(tmp == NULL)
    {
        fprintf(stderr, "the tree is null.\n");
        return ERROR;
    }

    while(tmp != NULL || (IsEmpty(&s) != 1))
    {
        while(tmp != NULL)
        {
            Push(&s, tmp);
            tmp = tmp->lchild;
        }

        if(IsEmpty(&s) != 1)
        {
            Pop(&s, &tmp);
            printf("%c ", tmp->data);
            tmp = tmp->rchild;
        }
    }
    return OK;
}

• 后序遍历
  
  基本思想：先后序遍历左子树，然后再后序遍历右子树，最后再访问根结点即左—右—根。

后序递归遍历
//后序递归遍历
void PostOrderTraverse(BiTree t)
{
if(t != NULL)
{
PostOrderTraverse(t->lchild);
PostOrderTraverse(t->rchild);
printf("%c ", t->data);
}
}
后序遍历的非递归

//后序非递归遍历二叉树
int NoPostOrderTraverse(BiTree t)
{
    SqStack s;
    InitStack(&s);

    BiTree cur;     //当前结点  
    BiTree pre = NULL;      //前一次访问的结点
    BiTree tmp;

    if(t == NULL)
    {
        fprintf(stderr, "the tree is null.\n");
        return ERROR;
    }

    Push(&s, t);
    while(IsEmpty(&s) != 1)
    {
        GetTop(&s, &cur);//
        if((cur->lchild == NULL && cur->rchild == NULL) || (pre != NULL && (pre == cur->lchild || pre == cur->rchild)))
        {
            printf("%c ", cur->data);    //如果当前结点没有孩子结点或者孩子结点都已被访问过
            Pop(&s, &tmp);
            pre = cur;
        }
        else
        {
            if(cur->rchild != NULL)
            {
                Push(&s, cur->rchild);
            }
            if(cur->lchild != NULL)
            {
                Push(&s, cur->lchild);
            }
        }
    }
    return OK;
}

二叉树的查找

bintree search_tree(bintree t,datatype x){
if(!t){
return NULL;
}
if(t->data == x){
return t;
}else{
if(!search_tree(t->lchild,x)){
return search_tree(t->rchild,x);
}
return t;
}
}

二叉树的作用

二叉排序树是一种比较有用的折衷方案。
数组的搜索比较方便，可以直接用下标，但删除或者插入某些元素就比较麻烦。
链表与之相反，删除和插入元素很快，但查找很慢。
二叉排序树就既有链表的好处，也有数组的好处。
在处理大批量的动态的数据是比较有用。
用的最多的应该是平衡二叉树，有种特殊的平衡二叉树红黑树，查找、插入、删除的时间复杂度最坏为O(log n)
平衡二叉树/红黑树就是为了将查找的时间复杂度保证在O(logN)范围内。
二叉树之所以重要，是因为它支持或拥有的操作，包括增删改查重要的操作，复杂度比完成同样功能的其他结构更低。