大话数据结构之二叉树c++实现

二叉树

参考大话数据结构和B站up主码农论坛

file BinaryTree.h

#pragma once
#include <iostream>
using namespace std;

typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode, *BiTree;

 手工构造一个如下结构的二叉树。
//             1
//          /     \
//         2       3
//        / \     /
//       4   5   6
//      / \ / \
//     7  8 9  0

class BinaryTree
{
public:
    BinaryTree();
    ~BinaryTree(void);

    void ArtificalTree(BiTree *pTT);
    void ArtificalTree(BiTree &TT);

    // 二叉树层次遍历。
    void LevelOrder();
    
    // 非递归
    void PreOrder();
    void InOrder();
    void PostOrder();

    // 递归
    void PreOrderRecur();
    void InOrderRecur();
    void PostOrderRecur();
    void PreOrderRecurProcess(BiTree TT);
    void InOrderRecurProcess(BiTree TT);
    void PostOrderRecurProcess(BiTree TT);

private:
    BiTree m_BinTree;
};

file BinaryTree.cpp

/*
    // 手工构造一个如下结构的二叉树。
             1
          /     \
         2       3
        / \     /
       4   5   6
      / \ / \
     7  8 9  0
*/

#include "BinaryTree.h"
#include <queue>
#include <stack>

BinaryTree::BinaryTree():m_BinTree(nullptr)
{
    ArtificalTree(m_BinTree);
}

BinaryTree::~BinaryTree(void)
{
}

void BinaryTree::ArtificalTree(BiTree *pTT) // xxx
{
    BiTNode* head = new BiTNode;

    head->data = '1';
    head->lchild = head->rchild = nullptr;

    head->lchild = new BiTNode;
    head->rchild = new BiTNode;
    head->lchild->data = '2';
    head->lchild->lchild = head->lchild->rchild = nullptr;
    head->rchild->data = '3';
    head->rchild->lchild = nullptr;
    head->rchild->rchild = nullptr;

    head->lchild->lchild = new BiTNode;
    head->lchild->rchild = new BiTNode;
    head->rchild->lchild = new BiTNode;
    head->lchild->lchild->data = '4';
    head->lchild->lchild->lchild = nullptr;
    head->lchild->lchild->rchild = nullptr;
    head->lchild->rchild->data = '5';
    head->lchild->rchild->lchild = nullptr;
    head->lchild->rchild->rchild = nullptr;
    head->rchild->lchild->data = '6';
    head->rchild->lchild->lchild = nullptr;
    head->rchild->lchild->rchild = nullptr;

    head->lchild->lchild->lchild = new BiTNode;
    head->lchild->lchild->rchild = new BiTNode;
    head->lchild->rchild->lchild = new BiTNode;
    head->lchild->rchild->rchild = new BiTNode;
    head->lchild->lchild->lchild->data = '7';
    head->lchild->lchild->lchild->lchild = nullptr;
    head->lchild->lchild->lchild->rchild = nullptr;
    head->lchild->lchild->rchild->data = '8';
    head->lchild->lchild->rchild->lchild = nullptr;
    head->lchild->lchild->rchild->rchild = nullptr;
    head->lchild->rchild->lchild->data = '9';
    head->lchild->rchild->lchild->lchild = nullptr;
    head->lchild->rchild->lchild->rchild = nullptr;
    head->lchild->rchild->rchild->data = '0';
    head->lchild->rchild->rchild->lchild = nullptr;
    head->lchild->rchild->rchild->rchild = nullptr;

    *pTT = head; // xxx
}

void BinaryTree::ArtificalTree(BiTree &TT) // xxx
{
    BiTNode* head = new BiTNode;

    head->data = '1';
    head->lchild = head->rchild = nullptr;

    head->lchild = new BiTNode;
    head->rchild = new BiTNode;
    head->lchild->data = '2';
    head->lchild->lchild = head->lchild->rchild = nullptr;
    head->rchild->data = '3';
    head->rchild->lchild = nullptr;
    head->rchild->rchild = nullptr;

    head->lchild->lchild = new BiTNode;
    head->lchild->rchild = new BiTNode;
    head->rchild->lchild = new BiTNode;
    head->lchild->lchild->data = '4';
    head->lchild->lchild->lchild = nullptr;
    head->lchild->lchild->rchild = nullptr;
    head->lchild->rchild->data = '5';
    head->lchild->rchild->lchild = nullptr;
    head->lchild->rchild->rchild = nullptr;
    head->rchild->lchild->data = '6';
    head->rchild->lchild->lchild = nullptr;
    head->rchild->lchild->rchild = nullptr;

    head->lchild->lchild->lchild = new BiTNode;
    head->lchild->lchild->rchild = new BiTNode;
    head->lchild->rchild->lchild = new BiTNode;
    head->lchild->rchild->rchild = new BiTNode;
    head->lchild->lchild->lchild->data = '7';
    head->lchild->lchild->lchild->lchild = nullptr;
    head->lchild->lchild->lchild->rchild = nullptr;
    head->lchild->lchild->rchild->data = '8';
    head->lchild->lchild->rchild->lchild = nullptr;
    head->lchild->lchild->rchild->rchild = nullptr;
    head->lchild->rchild->lchild->data = '9';
    head->lchild->rchild->lchild->lchild = nullptr;
    head->lchild->rchild->lchild->rchild = nullptr;
    head->lchild->rchild->rchild->data = '0';
    head->lchild->rchild->rchild->lchild = nullptr;
    head->lchild->rchild->rchild->rchild = nullptr;

    TT = head; // xxx
}

void BinaryTree::LevelOrder()
{
    queue<BiTree> qq; 
    qq.push(m_BinTree);

    while (!qq.empty())
    {
        cout << qq.front()->data << " ";
        BiTNode *tmp = qq.front();
        qq.pop();

        if (tmp->lchild != nullptr) qq.push(tmp->lchild);
        if (tmp->rchild != nullptr) qq.push(tmp->rchild);
    }
    return;
}

void BinaryTree::PreOrder()
{
    stack<BiTree> ss; 
    BiTNode *tmp = m_BinTree;   

    while ( (tmp!=NULL) || (!ss.empty()) )
    {
        if (tmp!=NULL)
        {
            cout << tmp->data << " ";   // 入栈前访问。
            ss.push(tmp);               // 入栈。
            tmp=tmp->lchild;            // 继续处理左子树。
        }
        else
        {
            BiTNode *ee = ss.top();
            ss.pop();                   // 出栈。
            tmp=ee->rchild;             // 处理右子树。 
        }
    }
    return;
}

void BinaryTree::InOrder()
{
    stack<BiTree> ss; 
    BiTNode *tmp = m_BinTree;   

    while ( (tmp!=NULL) || (!ss.empty()) )
    {
        if (tmp!=NULL)
        {
            ss.push(tmp);               // 入栈。
            tmp=tmp->lchild;            // 继续处理左子树。
        }
        else
        {
            BiTNode *ee = ss.top();
            ss.pop();                   // 出栈。
            cout << ee->data << " ";          
            tmp=ee->rchild;             // 处理右子树。 
        }
    }
    return;
}

void BinaryTree::PostOrder()
{
    stack<BiTree> ss;
    BiTNode *ee = m_BinTree;  
  
    BiTNode *pp=NULL; // 最近访问过的结点。

    while ( (ee!=NULL) || (!ss.empty()) )
    {
        if (ee!=NULL)    // 从根结点开始，沿树的左结点，依次入栈，直到左结点为空。
        {
            ss.push(ee);
            ee=ee->lchild;
        }
        else   // 转向右。
        {
            // 读取栈顶元素，不出栈。
            ee = ss.top();     

            // 如果右子树存在并且没有被访问过。
            if ( (ee->rchild!=NULL) && (ee->rchild!=pp) )
            {
                ee=ee->rchild;  // 转向右。
                ss.push(ee);  // 右子树的根结点入栈。
                ee=ee->lchild;  // 再转向右子树的左结点。
            }
            else  
            {
                ss.pop();  // 将结点弹出。
                cout << ee->data << " ";     // 访问结点。
                pp=ee;         // 记下最近访问过的结点。
                ee=NULL;       // 结点访问完后，重置ee为空，继续读取栈顶元素。
            }
        }
    }
}

void BinaryTree::PreOrderRecur()
{
    PreOrderRecurProcess(m_BinTree);
}
void BinaryTree::PreOrderRecurProcess(BiTree TT)
{
    if (TT == nullptr) return;

    cout << TT->data << " ";
    PreOrderRecurProcess(TT->lchild);
    PreOrderRecurProcess(TT->rchild);
}

void BinaryTree::InOrderRecur()
{
    InOrderRecurProcess(m_BinTree);
}
void BinaryTree::InOrderRecurProcess(BiTree TT)
{
    if (TT == nullptr) return;

    InOrderRecurProcess(TT->lchild);
    cout << TT->data << " ";
    InOrderRecurProcess(TT->rchild);
}

void BinaryTree::PostOrderRecur()
{
    PostOrderRecurProcess(m_BinTree);
}
void BinaryTree::PostOrderRecurProcess(BiTree TT)
{
    if (TT == nullptr) return;

    PostOrderRecurProcess(TT->lchild);
    PostOrderRecurProcess(TT->rchild);
    cout << TT->data << " ";
}

file main.cpp

#include <queue>
#include <stack>
#include "BinaryTree.h"

void myPrint(char *strInfo)
{
    cout << "\n" << strInfo << "..." << endl;
}

int main()
{  
    BinaryTree myBiTree;
    myPrint("层序遍历"); myBiTree.LevelOrder();
    myPrint("先序遍历"); myBiTree.PreOrder();
    myPrint("先序遍历递归版"); myBiTree.PreOrderRecur();
    myPrint("中序遍历"); myBiTree.InOrder();
    myPrint("中序遍历递归版"); myBiTree.InOrderRecur();
    myPrint("后序遍历"); myBiTree.PostOrder();
    myPrint("后序遍历递归版"); myBiTree.PostOrderRecur();

    cout << endl;
    system("pause");
    return 0;
}

五级标题

六级标题