树之二叉树的建立与四种遍历（前序，中序， 后序， 层次）及树的深度

前言

• ### 建立
• ### 前序遍历
• ### 中序遍历
• ### 后序遍历
• ### 层次遍历
• ### 求二叉树深度

求二叉树宽度

---

二叉树的建立与遍历

code

#include<stdio.h>
#include<malloc.h>
#include<iostream>
using namespace std;


typedef struct BTNode
{
    char data;
    struct BTNode *lchild, *rchild;
}BTNode;

void CreateTree(BTNode *& T)
{
    char c;
    cin >> c;
    if (c == '0')   //以0作为结束标志
    {
        T = NULL;
    }
    else
    {
        T = (BTNode *)malloc(sizeof(BTNode));
        T->data = c;
        CreateTree(T->lchild);
        CreateTree(T->rchild);
    }

}

//先序
void preOrder(BTNode *T)
{
    if (T)
    {
        printf("%c\n", T->data);
        preOrder(T->lchild);
        preOrder(T->rchild);
    }
}

//中序
void inOrder(BTNode *T)
{
    if (T)
    {
        inOrder(T->lchild);
        printf("%c\n", T->data);
        inOrder(T->rchild);
    }
}

//后序
void postOrder(BTNode *T)
{
    if (T)
    {
        postOrder(T->lchild);
        postOrder(T->rchild);
        printf("%c\n", T->data);
    }
}

int main()
{
    // eg:abc000d00
    BTNode *T;
    CreateTree(T);
    preOrder(T);
    printf("\n");
    inOrder(T);
    printf("\n");
    postOrder(T);
    printf("\n");
    return 0;
}

层次遍历

---

//层次遍历
void level(BTNode *T)
{
    int front, rear;
    BTNode *que[MaxSize];
    front = rear = 0;
    BTNode *q;
    if (T)
    {
        rear = (rear + 1) % MaxSize;
        que[rear] = T;
        while (front != rear)
        {
            front = (front + 1) % MaxSize;
            q = que[front];
            printf("%c", q->data);
            if (q->lchild)
            {
                rear = (rear + 1) % MaxSize;
                que[rear] = q->lchild;
            }
            if (q->rchild)
            {
                rear = (rear + 1) % MaxSize;
                que[rear] = q->rchild;
            }
        }
    }
}

求二叉树深度函数

---

int getDepth(BTNode *T)
{
    int LD, RD;
    if (T == NULL)
    {
        return 0;
    }
    else
    {
        LD = getDepth(T->lchild);
        RD = getDepth(T->rchild);
        return (LD > RD ? LD : RD) + 1;
    }
}

求二叉树的宽度

---

//顺序非循环队列的队列元素，可以存储结点指针和结点所在层次
typedef struct
{
    BTNode *p;
    int lno;
}St;

//求二叉树的宽度
int maxNode(BTNode *b)
{
    St que[MaxSize];
    int front, rear;
    int Lno, i, j, n, max;
    front = rear = 0;
    BTNode *q;
    if (b)
    {
        ++rear;
        que[rear].p = b;
        que[rear].lno = 1;
        while (front != rear)
        {
            ++front;
            q = que[front].p;
            Lno = que[front].lno;  //存取当前结点层次数
            if (q->lchild)
            {
                ++rear;
                que[rear].p = q->lchild;
                que[rear].lno = Lno + 1;  //根据当前结点推知层次数
            }
            if (q->rchild)
            {
                ++rear;
                que[rear].p = q->rchild;
                que[rear].lno = Lno + 1;  //根据当前结点推知层次数
            }
        }
        //循环结束时Lno保存的是这颗二叉树的最大层数即为深度
        printf("Lno: %d\n", Lno);
        max = 0;
        for (i = 1; i <= Lno; i++)
        {
            n = 0;
            for (j = 0; j < rear; j++)
            {
                if (que[j].lno == i)
                {
                    ++n;
                }
                if (n > max)
                {
                    max = n;
                }
            }
        }
        return max;
    }
    return 0;
}