二叉樹基礎-二叉樹類模板的實現（資料結構基礎第5周）

阿新 • • 發佈：2019-02-16

這裡參考了課本配套的程式簡單實現了二叉樹類模板，主要包含了二叉樹的建立和各種遍歷方法。
對於二叉樹的建立，這裡使用的是前序遍歷的方法建立的二叉樹，具體如下：
這裡寫圖片描述
這裡我使用的下圖中的二叉樹作為測試案例：

具體不說了，詳見程式碼吧。
原始碼
//test.cpp

#include <iostream>
#include "BinaryTree.h"
#include "BinaryTreeNode.h"
#include <vector>
using namespace std;

//前序方法遞迴建立二叉樹
BinaryTreeNode<char>* createTree() {
    BinaryTreeNode<char 
> *p;//這是使用區域性變數是有風險的，函式結束後會被釋放
    char ch;
    cin >> ch;
    if (ch=='#'){
        return NULL;
    }
    p = new BinaryTreeNode<char>(ch);
    p->setLeftchild(createTree());
    p->setRightchild(createTree());
    return p;
} 

void printTrsverse(const vector<char>& v) {
    for 
 (int i=0; i<v.size(); i++)
    {
        cout << v.at(i);
    }
    cout << endl;
}

//示例，輸入"ABD##EG###C#FH##I##"
int main() {
    BinaryTree<char> tr;
    tr.Initialize(createTree());
    vector<char> v;
    v=tr.traversePreOrder();
    cout << "前序遞迴遍歷：" << endl;
    printTrsverse(v);

    v=tr.traverseInOrder();
    cout 
 << "中序遞迴遍歷：" << endl;
    printTrsverse(v);

    v=tr.traversePostOrder();
    cout << "後序遞迴遍歷：" << endl;
    printTrsverse(v);

    v=tr.traversePreOrderWithoutRecusion();
    cout << "前序非遞迴遍歷：" << endl;
    printTrsverse(v);

    v=tr.traverseInOrderWithoutRecusion();
    cout << "中序非遞迴遍歷：" << endl;
    printTrsverse(v);

    v=tr.traversePostOrderWithoutRecusion();
    cout << "後序非遞迴遍歷：" << endl;
    printTrsverse(v);

    v=tr.traversePostOrderWithoutRecusion2();
    cout << "後序非遞迴遍歷2：" << endl;
    printTrsverse(v);

    v=tr.traverseLevelOrder();
    cout << "層次遍歷：" << endl;
    printTrsverse(v);
    return 0;
}

//BinaryTree.h

#pragma once

#include "BinaryTreeNode.h"
#include <stack>
#include <queue>
#include <vector>
using namespace std;


enum Tags{Left,Right};

template <class T>
class StackElement
{
public:
    BinaryTreeNode<T>* pointer;
    Tags tag;
};

template <class T>
class BinaryTree  
{
private:
    BinaryTreeNode<T>*  root;                               //二叉樹根結點指標
    vector<T> elements;  //用於儲存遍歷的元素
private:
    void Visit(T elem) {elements.push_back(elem);};  //遍歷訪問元素的值
    void PreOrder(BinaryTreeNode<T>* root); //從root前序遍歷二叉樹或其子樹(遞迴部分)
    void InOrder(BinaryTreeNode<T>* root);  //從root中序遍歷二叉樹或其子樹（遞迴部分）    
    void PostOrder(BinaryTreeNode<T>* root); //從root後序遍歷二叉樹或其子樹(遞迴部分)   
    void PreOrderWithoutRecusion(BinaryTreeNode<T>* root); //從root非遞迴前序遍歷二叉樹或其子樹(遞迴部分)  
    void InOrderWithoutRecusion(BinaryTreeNode<T>* root);  //從root非遞迴中序遍歷二叉樹或其子樹(遞迴部分)  
    void PostOrderWithoutRecusion(BinaryTreeNode<T>* root);  //從root非遞迴後序遍歷二叉樹或其子樹  (遞迴部分)
    void PostOrderWithoutRecusion2(BinaryTreeNode<T>* root);  //從root非遞迴後序遍歷二叉樹或其子樹, 另一個版本(遞迴部分)
    void LevelOrder(BinaryTreeNode<T>* root);  //按層次遍歷二叉樹或其子樹
    BinaryTreeNode<T>* GetParent(BinaryTreeNode<T>* root,BinaryTreeNode<T>* current);//遞迴由root結點查詢current結點的父結點

public:
    BinaryTree(){root=NULL;};                               //建構函式
    virtual ~BinaryTree(){DeleteBinaryTree(root);};            //解構函式
    bool isEmpty() const                            
    {return ((root)?TRUE:FALSE);};                          //判定二叉樹是否為空樹

    void Initialize(BinaryTreeNode<T>* pointer) {root=pointer;};    

    BinaryTreeNode<T>* Root() {return root;};  //返回二叉樹根節點
    BinaryTreeNode<T>* Parent(BinaryTreeNode<T>* current); //返回current結點的父結點指標  
    BinaryTreeNode<T>* LeftSibling(BinaryTreeNode<T>* current); //返回current結點的左兄弟   
    BinaryTreeNode<T>* RightSibling(BinaryTreeNode<T>* current);//返回current結點的右兄弟

    //以elem作為根結點，leftTree作為樹的左子樹，rightTree作為樹的右子樹，構造一棵新的二叉樹
    void CreateTree(const T& elem, BinaryTree<T>& leftTree, BinaryTree<T>& rightTree);  
    void DeleteBinaryTree(BinaryTreeNode<T>* root);     //遞迴刪除二叉樹或其子樹   

    vector<T> traversePreOrder();  //從根節點前序遍歷，以下依次對應
    vector<T> traverseInOrder();
    vector<T> traversePostOrder();
    vector<T> traversePreOrderWithoutRecusion();
    vector<T> traverseInOrderWithoutRecusion();
    vector<T> traversePostOrderWithoutRecusion();
    vector<T> traversePostOrderWithoutRecusion2();
    vector<T> traverseLevelOrder();     
};

template<class T>
BinaryTreeNode<T>* BinaryTree<T>::GetParent(BinaryTreeNode<T>* root,BinaryTreeNode<T>* current)
{
    //從二叉樹的root結點開始，查詢current結點的父結點
    BinaryTreeNode<T>* temp;
    if(root==NULL)
        return NULL;
    //找到父結點
    if((root->leftchild()==current)||(root->rightchild()==current))
        return root;
    //遞迴尋找父結點
    if((temp=GetParent(root->leftchild(),current))!=NULL)
        return temp;
    else return GetParent(root->rightchild(),current);  
}

template<class T>
BinaryTreeNode<T>* BinaryTree<T>::Parent(BinaryTreeNode<T>* current)  //返回current結點的父結點指標
{
    if((current==NULL)||(current==root))
        return NULL;                    //空結點或者current為根結點時，返回NULL
    return GetParent(root,current);     //呼叫遞迴函式尋找父結點
}

template<class T>
BinaryTreeNode<T>* BinaryTree<T>::LeftSibling(BinaryTreeNode<T>* current)  //返回current結點的左兄弟
{
    if(current)                                         //current不為空
    {
        BinaryTreeNode<T>* temp=Parent(current);    //返回current結點的父結點
        if((temp==NULL)||current==temp->leftchild())
            return  NULL;           //如果父結點為空，或者current沒有左兄弟
        else return temp->leftchild();
    }
    return NULL;
}

template<class T>
BinaryTreeNode<T>* BinaryTree<T>::RightSibling(BinaryTreeNode<T>* current) //返回current結點的右兄弟
{
    if(current)                                 //current不為空
    {
        BinaryTreeNode<T>* temp=Parent(current);//返回current結點的父結點
        if((temp==NULL)||current==temp->rightchild())
            return  NULL;                   //如果父結點為空，或者current沒有右兄弟
        else return temp->rightchild();
    }
    return NULL;
}

template<class T>
void BinaryTree<T>::CreateTree(const T& elem, BinaryTree<T>& leftTree, BinaryTree<T>& rightTree) //以elem作為根結點，leftTree作為樹的左子樹，rightTree作為樹的右子樹，構造一棵新的二叉樹
{
    root=new BinaryTreeNode<T>(elem,leftTree.root,rightTree.root);  //建立新樹
    leftTree.root=rightTree.root=NULL;                              //原來兩棵子樹的根結點指空，避免訪問
}

template<class T>
void BinaryTree<T>::DeleteBinaryTree(BinaryTreeNode<T>* root)       //遞迴刪除二叉樹或其子樹
{
    if(root)
    {
        DeleteBinaryTree(root->left);
        DeleteBinaryTree(root->right);
        delete root;
    };
};

template<class T>
void BinaryTree<T>::PreOrder(BinaryTreeNode<T>* root)               //前序遍歷二叉樹或其子樹
{
    if(root!=NULL)
    {
        Visit(root->value());   
        PreOrder(root->leftchild());            //訪問左子樹
        PreOrder(root->rightchild());           //訪問右子樹
    }
};
template<class T>
vector<T> BinaryTree<T>::traversePreOrder() 
{
    elements.clear();
    PreOrder(root);
    return elements;
}

template<class T>
void BinaryTree<T>::InOrder(BinaryTreeNode<T>* root)                //中序遍歷二叉樹或其子樹
{
    if(root!=NULL)
    {
        InOrder (root->leftchild());            //訪問左子樹
        Visit(root->value());           //訪問當前結點
        InOrder (root->rightchild());           //訪問右子樹
    }
}
template<class T>
vector<T> BinaryTree<T>::traverseInOrder() 
{
    elements.clear();
    InOrder(root);
    return elements;
}

template<class T>
void BinaryTree<T>::PostOrder(BinaryTreeNode<T>* root)              //後序遍歷二叉樹或其子樹
{
    if(root!=NULL)
    {
        PostOrder(root->leftchild());           //訪問左子樹
        PostOrder (root->rightchild());         //訪問右子樹
        Visit(root->value());           //訪問當前結點
    }
}
template<class T>
vector<T> BinaryTree<T>::traversePostOrder() 
{
    elements.clear();
    PostOrder(root);
    return elements;
}

template<class T>
void BinaryTree<T>::PreOrderWithoutRecusion(BinaryTreeNode<T>* root)//非遞迴前序遍歷二叉樹或其子樹
{
//  using std::stack;

    stack<BinaryTreeNode<T>* > aStack;
    BinaryTreeNode<T>* pointer=root;                //儲存輸入引數    

    while(!aStack.empty()||pointer)             
    {
        if(pointer){
            Visit(pointer->value());        //訪問當前結點
            aStack.push(pointer);                   //當前結點地址入棧
            pointer=pointer->leftchild();           //當前連結結構指向左孩子
        }
        else {                                          //左子樹訪問完畢，轉向訪問右子樹
            pointer=aStack.top();                   //棧頂元素退棧                 
            aStack.pop();
            pointer=pointer->rightchild();      //當前連結結構指向右孩子
        } //else
    } //while
}
template<class T>
vector<T> BinaryTree<T>::traversePreOrderWithoutRecusion() 
{
    elements.clear();
    PreOrderWithoutRecusion(root);
    return elements;
}

template<class T>
void BinaryTree<T>::InOrderWithoutRecusion(BinaryTreeNode<T>* root) //非遞迴中序遍歷二叉樹或其子樹
{
//  using std::stack;
    stack<BinaryTreeNode<T>* > aStack;
    BinaryTreeNode<T>* pointer=root;                //儲存輸入引數    

    while(!aStack.empty()||pointer)             
    {
        if(pointer){
            aStack.push(pointer);                   //當前結點地址入棧
            pointer=pointer->leftchild();           //當前連結結構指向左孩子
        }
        else {                                          //左子樹訪問完畢，轉向訪問右子樹
            pointer=aStack.top();               
            Visit(pointer->value());        //訪問當前結點
            pointer=pointer->rightchild();      //當前連結結構指向右孩子
            aStack.pop();                           //棧頂元素退棧                 
        } //else
    } //while
}
template<class T>
vector<T> BinaryTree<T>::traverseInOrderWithoutRecusion() 
{
    elements.clear();
    InOrderWithoutRecusion(root);
    return elements;
}

template<class T>
void BinaryTree<T>::PostOrderWithoutRecusion(BinaryTreeNode<T>* root)//非遞迴後序遍歷二叉樹或其子樹
{
//  using std::stack;
    StackElement<T> element;
    stack<StackElement<T > > aStack;
    BinaryTreeNode<T>* pointer;
    if(NULL==root)
        return;                                     //空樹即返回
    else pointer=root;
    while(true)
    {
        //進入左子樹
        while(pointer!=NULL)
        {
            element.pointer=pointer;
            element.tag=Left;
            aStack.push(element);
            pointer=pointer->leftchild();
        }
        //托出棧頂元素
        element=aStack.top();
        aStack.pop();
        pointer=element.pointer;
        //從右子樹回來
        while(element.tag==Right)
        {
            Visit(pointer->value());        //訪問當前結點
            if(aStack.empty())
                return;
            else
            {
                element=aStack.top();
                aStack.pop();
                pointer=element.pointer;
            }
        }
        //從左子樹回來
        element.tag=Right;
        aStack.push(element);
        pointer=pointer->rightchild();
    }
}
template<class T>
vector<T> BinaryTree<T>::traversePostOrderWithoutRecusion() 
{
    elements.clear();
    PostOrderWithoutRecusion(root);
    return elements;
}

template<class T>
void BinaryTree<T>::PostOrderWithoutRecusion2(BinaryTreeNode<T>* root)
{//非遞迴後序遍歷二叉樹或其子樹, 另一個版本
//  using std::stack;
    stack<BinaryTreeNode<T>* > aStack;
    BinaryTreeNode<T> *p, *q;
    if(root==NULL)
        return;
    p=root;
    do{
        while(p!=NULL)                          //沿左路分支下降           
        {
            aStack.push(p);
            p=p->leftchild();
        }
        q=NULL;
        while(!aStack.empty())
        {
            p=aStack.top();
            aStack.pop();
            if(p->rightchild()==q)              //右子樹為空或剛剛被訪問過
            {
                Visit(p->value());      //訪問當前結點
                q=p;
            }
            else
            {
                aStack.push(p);
                p=p->rightchild();
                break;
            }
        }
    }while(!aStack.empty());
}
template<class T>
vector<T> BinaryTree<T>::traversePostOrderWithoutRecusion2() 
{
    elements.clear();
    PostOrderWithoutRecusion2(root);
    return elements;
}

template<class T>
void BinaryTree<T>::LevelOrder(BinaryTreeNode<T>* root) //按層次遍歷二叉樹或其子樹,這裡使用佇列來模擬
{
//  using std::queue;
    queue<BinaryTreeNode<T>*> aQueue;
    BinaryTreeNode<T>* pointer=root;

    if(pointer)
        aQueue.push(pointer);
    while(!aQueue.empty())
    {
        pointer=aQueue.front();
        Visit(pointer->value());        //訪問當前結點
        aQueue.pop();
        if(pointer->leftchild())
            aQueue.push(pointer->leftchild());
        if(pointer->rightchild())
            aQueue.push(pointer->rightchild());
    }
}
template<class T>
vector<T> BinaryTree<T>::traverseLevelOrder() 
{
    elements.clear();
    LevelOrder(root);
    return elements;
}

//BinaryTreeNode.h

#pragma once

template <class T> class BinaryTree;

template <class T>
class BinaryTreeNode  
{
friend class BinaryTree<T>;
private:
    T  element;                                         //二叉樹結點資料域
    BinaryTreeNode<T>*  left;                           //二叉樹結點指向左子樹的指標
    BinaryTreeNode<T>*  right;                          //二叉樹結點指向左子樹的指標
public:
    BinaryTreeNode();
    BinaryTreeNode(const T& ele);                       //給定資料的建構函式
    BinaryTreeNode(const T& ele,BinaryTreeNode* l, BinaryTreeNode* r);//給定資料的左右指標的建構函式
    T  value() const;                                   //返回當前結點的資料
    BinaryTreeNode<T>& operator= (const BinaryTreeNode<T>& Node)
    {this=Node;};                                       //過載賦值操作符
    BinaryTreeNode<T>*  leftchild() const;              //返回當前結點指向左子樹的指標
    BinaryTreeNode<T>*  rightchild() const;             //返回當前結點指向右子樹的指標
    void  setLeftchild(BinaryTreeNode<T>*);             //設定當前結點的左子樹
    void  setRightchild(BinaryTreeNode<T>*);            //設定當前結點的右子樹
    void  setValue(const T& val);                       //設定當前結點的資料域
    bool  isLeaf() const;                               //判定當前結點是否為葉結點,若是返回true
};

template<class T>
BinaryTreeNode<T>::BinaryTreeNode()
{
    left=right=NULL;
}

template<class T>
BinaryTreeNode<T>::BinaryTreeNode(const T& ele) //給定資料的建構函式
{
    element=ele;
    left=right=NULL;
}

template<class T>
BinaryTreeNode<T>::BinaryTreeNode(const T& ele,BinaryTreeNode* l, BinaryTreeNode* r)
    //給定資料的左右指標的建構函式
{
    element=ele;
    left=l;
    right=r;
}

template<class T>
T  BinaryTreeNode<T>::value() const
{
    return element; 
}

template<class T>
BinaryTreeNode<T>*  BinaryTreeNode<T>::leftchild() const
{
    return left;                                //返回當前結點指向左子樹的指標
}

template<class T>
BinaryTreeNode<T>*  BinaryTreeNode<T>::rightchild() const
{
    return right;                               //返回當前結點指向右子樹的指標
}   

template<class T>
void  BinaryTreeNode<T>::setLeftchild(BinaryTreeNode<T>* subroot)//設定當前結點的左子樹
{
    left=subroot;
}

template<class T>
void  BinaryTreeNode<T>::setRightchild(BinaryTreeNode<T>* subroot)//設定當前結點的右子樹
{
    right=subroot;
}

template<class T>
void  BinaryTreeNode<T>::setValue(const T& val) //設定當前結點的資料域
{
    element = val; 
} 

template<class T>
bool  BinaryTreeNode<T>::isLeaf() const         //判定當前結點是否為葉結點,若是返回true
{
    return (left == NULL) && (right == NULL); 
}

———————————2016.7.8記———————————————————————————–
上述test.cpp的createTree函式是有風險的，因為每次在函式內定義一個新結點，這樣在函式結束時就被釋放了。關於此問題很容易被忽視，詳見：二叉樹基礎-由中根序列和後根序列重建二叉樹（資料結構基礎第5周）

二叉樹基礎-二叉樹類模板的實現（資料結構基礎第5周）

這裡參考了課本配套的程式簡單實現了二叉樹類模板，主要包含了二叉樹的建立和各種遍歷方法。對於二叉樹的建立，這裡使用的是前序遍歷的方法建立的二叉樹，具體如下：這裡我使用的下圖中的二叉樹作為測試案例：具體不說了，詳見程式碼吧。原始碼 //t

樹及其應用c語言實現（資料結構複習最全筆記）

樹一.樹的基本概念二.二叉樹 1.二叉樹的定義 2.二叉樹的性質此外在這裡在介紹下完美二叉樹的概念及重要性質完全二叉樹是效率很高的資料結構，完全二叉樹是由滿二叉樹而引出來的。對於深度為K的，有n個結點的二叉樹，當

棧與佇列-順序棧與鏈棧類模板的實現（資料結構基礎第3周）

這是用C++編寫的棧的類模板的實現，包括順序棧和鏈棧，並進行了簡單的測試。程式碼中srrStack類和lnkStack類均繼承於Stack類, Stack類可以看成是棧的邏輯結構（ADT抽象資料型別，Abstract Data Type）。注意這裡實現是棧與

構建二叉樹（資料結構，李春葆）

#include <stdio.h> #include <malloc.h> #include <stdlib.h> typedef struct node { char data; struct node* lchild; struct node* rch

樹的三種遍歷方法程式碼實現（資料結構）C語言

樹的三種遍歷方法：前序，中序和後序及其程式碼實現。在此分別總結先序，中序，後序的結點輸出順序。先序： 1.訪問根結點　　　　2.訪問左子樹　　　　3.訪問右子樹中序：1.訪問左子樹　　　 2.訪問

二維陣列右上左下遍歷（C程式設計進階第5周）

問題描述給定一個row行col列的整數陣列array，要求從array[0][0]元素開始，按從左上到右下的對角線順序遍歷整個陣列。輸入輸入的第一行上有兩個整數，依次為row和col。餘

指標與二維陣列練習-文字排版（C程式設計進階第5周）

程式設計題＃3：文字排版來源: POJ (Coursera宣告：在POJ上完成的習題將不會計入Coursera的最後成績。) 注意：總時間限制: 1000ms 記憶體限制: 65536kB 描述給一段英文短文，單詞之間以空格分隔（每個單詞包括其前後緊鄰的標點

JAVA核心技術I---JAVA基礎知識（資料結構基礎）

一：陣列（一）基本內容是與C一致的（二）陣列定義和初始化（1）宣告 int a[]; //a沒有new操作，沒有被分配記憶體，為null int[] b; //b沒有new操作，沒有被分配記憶體，為null（可以看做指標）

野生前端的資料結構基礎練習（7）——二叉樹

網上的相關教程非常多，基礎知識自行搜尋即可。習題主要選自Orelly出版的《資料結構與演算法javascript描述》一書。參考程式碼可見:https://github.com/dashnowords/blogs/tree/master/Structure/btree 一.二叉樹的

軟考：資料結構基礎——建立順序完全二叉樹

　　首先是關於樹，二叉樹，完全二叉樹的一些知識一、樹（一）、基本概念 1. 度：一個節點的子樹的個數 &

資料結構基礎篇-------7.1 完全二叉樹

/* * 完全二叉樹 * 2018.10.23 * @L.F * */ #include <stdio.h> #include <stdlib.h> //定義結點結構體 typedef struct node{ int id; //編

C++類模板實踐（二叉樹類）1

先貼上我程式碼（未成品，我就先寫了構造和析構，先序遍歷程式碼），需要用的人可以直接用。造輪子方便我去了解STL，瞭解程式碼。我寫程式碼時踩過的一些小坑，作為一些小知識：發生了幾個語法，編譯，連結bug。第一個：模板的typedef，得宣告型別：typedef

二叉樹之二叉連結串列的類模板實現

該類模板實現了一個二叉樹的模板類，採用二叉連結串列實現。定義二叉樹節點類，採用二叉連結串列實現。 [cpp] view plaincopyprint? ///////////////////////// #incl

[資料結構]二叉樹之二叉連結串列的類模板實現

該類模板實現了一個二叉樹的模板類，採用二叉連結串列實現。定義二叉樹節點類，採用二叉連結串列實現。///////////////////////// #include <iostream> #include <cstdlib> #include <

資料結構基礎溫故-4.樹與二叉樹（下）

上面兩篇我們瞭解了樹的基本概念以及二叉樹的遍歷演算法，還對二叉查詢樹進行了模擬實現。數學表示式求值是程式設計語言編譯中的一個基本問題，表示式求值是棧應用的一個典型案例，表示式分為字首、中綴和字尾三種形式。這裡，我們通過一個四則運算的應用場景，藉助二叉樹來幫助求解表示式的值。首先，將表示式轉換為二叉樹，然後通過

資料結構基礎溫故-4.樹與二叉樹（中）

在上一篇中，我們瞭解了樹的基本概念以及二叉樹的基本特點和程式碼實現，還用遞迴的方式對二叉樹的三種遍歷演算法進行了程式碼實現。但是，由於遞迴需要系統堆疊，所以空間消耗要比非遞迴程式碼要大很多。而且，如果遞迴深度太大，可能系統撐不住。因此，我們使用非遞迴（這裡主要是迴圈，迴圈方法比遞迴方法快, 因為迴圈避免了一系

資料結構基礎溫故-4.樹與二叉樹（上）

前面所討論的線性表元素之間都是一對一的關係，今天我們所看到的結構各元素之間卻是一對多的關係。樹在計算機中有著廣泛的應用，甚至在計算機的日常使用中，也可以看到樹形結構的身影，如下圖所示的Windows資源管理器和應用程式的選單都屬於樹形結構。樹形結構是一種典型的非線性結構，除了用於表示相鄰關係外，還可以表示層次

資料結構基礎層次遍歷和中序遍歷還原二叉樹

【問題描述】給出一個層次遍歷，和一箇中序遍歷的結果字串層次 A B C D E F G 中序 D B A F E G C 其對應的二叉樹是： A / / B C / / D E / /

【數據結構】——搜索二叉樹的插入，查找和刪除（遞歸&非遞歸）

type 樹操作 iss OS 操作 amp 方法查找搜索樹一、搜索二叉樹的插入，查找，刪除簡單說說搜索二叉樹概念：二叉搜索樹又稱二叉排序樹，它或者是一棵空樹，或者是具有以下性質的二叉樹若它的左子樹不為空，則左子樹上所有節點的值都小於根節點的值若它的右子樹不為

二叉樹的先序/中序/後序（遞迴、非遞迴）+層序遍歷

queue 的基本操作舉例如下： queue入隊，如例：q.push(x); 將x 接到佇列的末端。 queue出隊，如例：q.pop(); 彈出佇列的第一個元素，注意，並不會返回被彈出元素的值。訪問queue隊首元素，如例：q.front()，即最早被壓入佇列的元素。訪問que

二叉樹基礎-二叉樹類模板的實現（資料結構基礎 第5周）

相關推薦

二叉樹基礎-二叉樹類模板的實現（資料結構基礎第5周）