C++ 二叉树的层次建树及其遍历

总结归纳

  1. 先序遍历:根左右;中序遍历:左根右;后序遍历:左右根。
  2. 若选取层次建树,则需要一个链式队列辅助实现 (规定,不必问为什么) 。若选取层次遍历,也需要一个链式队列辅助实现。
  3. 该辅助队列的具体操作流程(重点理解): 队列结点的数据域 p 存放的是树结点的地址 ( BiTNode *p 类型 ) ,头指针 phead 指向该队列头部,尾指针 ptail 指向该队列尾部,队列指针 pCur 始终指向当前操作位置,当前操作位置指的是:有新结点加入二叉树时,新结点作为队列指针 pCur 所指向的树结点(队列结点的数据域)的子孩子。此时,若 pCur 所指向树结点的左孩子为空,将新结点置为该树结点的左孩子,并通过尾插法加入队列,更新队尾指针;若此时右孩子为空,将新结点置为该树结点的右孩子,更新队尾指针,因为此时 pCur 指针所指向的树结点左右孩子皆满,使得 pCur 指针右移,下次新结点入队时,pCur 指针指向的树结点的左孩子就又为空。
  4. 层次遍历的具体流程(重点理解): 首先使根结点入队,循环判断队列是否为空,若队列不为空,让队头出队,并使该队头结点指向的树结点的左右孩子入队(没有则不做处理),然后继续循环判断。根据队列先进先出的特性,每个头结点出队后,该头结点所指向的树结点的左右孩子立即入队,在逻辑上左右孩子紧邻头结点,符合层次遍历的要求。
  5. 层次建树的难点在于,较为复杂且难以理解,最后再总结一下:定义树结点,定义链式队列结点,队列结点的数据域为树结点的地址(BiTNode *p 类型)。树结点入树时,首先将队列结点通过尾插法入队,并通过 pCur 指针指向的队列结点的数据域拿到对应树结点的地址,再对左右孩子进行判空,然后入树。
  6. 在该代码中,pCur 是每次建树时重新定义的,所以在建树最后,要释放并置为 NULL ,如果不这么做,可以将 pCur 置为全局变量。也可以将头尾指针定义在队列内部,可以使得建树函数 BuildBinaryTree() 少传些参数,总之方法很多,均能实现。
  7. 该代码中所有函数均位于一个文件,弊端就在于:对于 EnQueue( ) 、DeQueue( ) 等函数需要根据树结点的定义特殊处理,我使用的 VS Code,只能出此下策。更好的办法是,利用 VS Studio 引用头文件的功能,直接引用封装好的队列代码,只需修改 typedef 对 ElemType 的重命名即可代替所有的特殊处理。

代码实践

#include <iostream>

#define MaxSize 10 // 栈中元素的最大个数

using namespace std;

typedef char ElemType;

// 树
struct BiTNode {
    ElemType data;            // 数据域
    BiTNode *lchild, *rchild; // 左孩子,右孩子
};

// 辅助队列结点,不带头结点,通过头指针 phead 访问
struct LinkNode {
    BiTNode *p; // 树中对应结点的地址
    LinkNode *pNext;
};

// 链式队列,辅助层次遍历
struct LinkQueue {
    LinkNode *front, *rear; // 队头指针,队尾指针
};

typedef BiTNode *BiTree; // 代指二叉树

// 树的初始化
bool InitTree(BiTree &T) {
    T = NULL;
    return true;
}

//层次建树
void BuildBinaryTree(BiTree &T, LinkNode *&phead, LinkNode *&ptail,
                     ElemType val) {
    // 此处申请空间,不能使用new,会进入死循环,我也不知道为啥
    BiTNode *pTreeNew =
        (BiTNode *)calloc(1, sizeof(BiTNode)); // 为树结点申请空间
    LinkNode *pQueueNew =
        (LinkNode *)calloc(1, sizeof(LinkNode)); // 为队列结点申请空间
    LinkNode *pCur = phead; // 始终指向当前操作位置

    pTreeNew->data = val;    // 树结点的赋值
    pQueueNew->p = pTreeNew; // 队列新结点的数据域为树的新结点

    if (T == NULL) { // 空树时,新结点置为树根
        T = pTreeNew;
        phead = pQueueNew;
        ptail = pQueueNew;
    } else {
        ptail->pNext = pQueueNew; //尾插法
        ptail = pQueueNew;        // 更新尾指针

        if (pCur->p->lchild == NULL) { // 左孩子为空
            pCur->p->lchild = pTreeNew;
        } else if (pCur->p->rchild == NULL) { // 右孩子为空
            pCur->p->rchild = pTreeNew;
            phead = pCur->pNext; //该结点左右孩子已满,队头指针后移
            free(pCur);          // 该代码中,PCur
                        // 是每次建树时重新定义的,所以在建树最后,要释放并置为
                        // NULL
            pCur = NULL;
        }
    }
}

//前序遍历(深度优先遍历):根左右
void PreOrder(BiTNode *p) {
    if (p != NULL) {
        putchar(p->data);
        PreOrder(p->lchild);
        PreOrder(p->rchild);
    }
}

// 中序遍历:左根右
void InOrder(BiTNode *p) {
    if (p != NULL) {
        InOrder(p->lchild);
        putchar(p->data);
        InOrder(p->rchild);
    }
}

// 后序遍历:左右根
void PostOrder(BiTNode *p) {
    if (p != NULL) {
        PostOrder(p->lchild);
        PostOrder(p->rchild);
        putchar(p->data);
    }
}

// 初始化队列
bool InitQueue(LinkQueue &Q) {
    Q.front = Q.rear = new LinkNode; // 为队列申请一个结点作为头结点
    Q.front->pNext = NULL;
    return true;
}

// 队列判空
bool QueueEmpty(LinkQueue &Q) {
    if (Q.front == Q.rear) {
        return true;
    } else {
        return false;
    }
}

// 入队
bool EnQueue(LinkQueue &Q, BiTNode *x) {
    LinkNode *p = new LinkNode;
    p->p = x;
    p->pNext = NULL;
    Q.rear->pNext = p; // 入队
    Q.rear = p;        // 更新队尾
    return true;
}

// 出队
bool DeQueue(LinkQueue &Q, BiTNode *&x) {
    if (Q.rear == Q.front) {
        return false;
    } else {
        LinkNode *p = Q.front->pNext; // 指向队头元素
        x = p->p;
        Q.front->pNext = p->pNext;
        if (Q.rear == p) { // 即队列中只剩一个元素
            Q.front = Q.rear;
        }
        delete p;
        return true;
    }
}

// 层序遍历,广度优先遍历
void LevelOrder(BiTree T) {
    LinkQueue Q;
    InitQueue(Q);
    BiTNode *p;
    EnQueue(Q, T); // 树根入队
    while (!QueueEmpty(Q)) {
        DeQueue(Q, p); // p为引用,此时p为对应的树结点
        putchar(p->data);
        if (p->lchild != NULL) {
            EnQueue(Q, p->lchild);
        }
        if (p->rchild != NULL) {
            EnQueue(Q, p->rchild); // 立即使p的左右孩子入队,保证层序遍历
        }
    }
}

int main() {
    ElemType val;
    BiTree T;
    InitTree(T);

    LinkNode *phead = NULL;
    LinkNode *ptail = NULL; // 头指针,尾指针
    while (scanf("%c", &val) != EOF) {
        if (val == '\n') {
            break;
        } else {
            BuildBinaryTree(T, phead, ptail, val);
        }
    }

    cout << "-----前序遍历-----" << endl;
    PreOrder(T);
    cout << endl;

    cout << "-----中序遍历-----" << endl;
    InOrder(T);
    cout << endl;

    cout << "-----后序遍历-----" << endl;
    PostOrder(T);
    cout << endl;

    cout << "-----层序遍历-----" << endl;
    LevelOrder(T);
    cout << endl;

    return 0;
}
  • 4
    点赞
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
根据提供的引用内容,可以通过层序遍历的方式来建立二叉树。具体的实现过程如下: 首先,需要定义一个二叉树数据结构和一个队列的数据结构二叉树的定义可以包括节点的数据和左右子节点的指针。队列可以使用数组或链表实现,用来存储节点指针。 接下来,可以借助一个辅助队列来进行层序遍历建树。首先,将二叉树的根节点入队。然后,循环执行以下操作:出队一个节点,访问该节点;如果该节点有左子树,则将左子树的根节点入队;如果该节点有右子树,则将右子树的根节点入队。直到队列为空时,建树的过程结束。 下面是一个示例的实现过程: ```c++ #include <iostream> #include <queue> using namespace std; struct Node { int data; Node* left; Node* right; }; Node* createNode(int data) { Node* newNode = new Node(); if (!newNode) { cout << "Memory error\n"; return NULL; } newNode->data = data; newNode->left = newNode->right = NULL; return newNode; } Node* insertNode(Node* root, int data) { // If the tree is empty, assign a new node address to the root if (root == NULL) { root = createNode(data); return root; } // Else, do level order traversal until we find an empty // position, i.e. either left child or right child of some // node is pointing to NULL. queue<Node*> q; q.push(root); while (!q.empty()) { Node* temp = q.front(); q.pop(); if (temp->left != NULL) q.push(temp->left); else { temp->left = createNode(data); return root; } if (temp->right != NULL) q.push(temp->right); else { temp->right = createNode(data); return root; } } return root; } void levelOrderTraversal(Node* root) { if (root == NULL) return; queue<Node*> q; q.push(root); while (!q.empty()) { Node* temp = q.front(); q.pop(); cout << temp->data << " "; if (temp->left != NULL) q.push(temp->left); if (temp->right != NULL) q.push(temp->right); } } int main() { Node* root = NULL; int data; // Insert nodes in level order root = insertNode(root, 1); root = insertNode(root, 2); root = insertNode(root, 3); root = insertNode(root, 4); root = insertNode(root, 5); // Level order traversal of the tree cout << "Level Order Traversal: "; levelOrderTraversal(root); return 0; } ``` 这段代码实现了二叉树层序遍历建树过程,并对建立好的二叉树进行层序遍历输出。你可以根据自己的需求进行修改和扩展。希望对你有帮助!<span class="em">1</span><span class="em">2</span> #### 引用[.reference_title] - *1* *2* [二叉树层序遍历c++)](https://blog.csdn.net/qq_45519325/article/details/129207375)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值