2. 程式人生 > >二叉樹的遍歷 C++模板+封裝

二叉樹的遍歷 C++模板+封裝

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

二叉樹的遍歷主要是前序、中序和後序遍歷（還有層序遍歷，參見：層序遍歷）

（一）遞迴形式

這三種遍歷訪問順序分別為：

前序：根->左子樹->右子樹
中序：左子樹->根->右子樹
後序：左子樹->右子樹->根

遞迴的形式來寫非常簡單，虛擬碼如下：

//前序遍歷
void PreOrder(TreeNode *root)
{
    if (root == NULL)
        return;
    Visit root->val;
    PreOrder(root->left);
    PreOrder(root->right);
}

//中序遍歷
 

void InOrder(TreeNode *root)
{
    if (root == NULL)
        return;
    InOrder(root->left);
    Visit root->val;
    InOrder(root->right);
}

//後序遍歷
void PostOrder(TreeNode *root)
{
    if (root == NULL)
        return;
    PostOrder(root->left);
    PostOrder(root->right);
    Visit root->val;
}

（二）非遞迴形式

非遞迴形式主要利用棧來實現各種順序遍歷時節點的訪問順序。

2.1非遞迴先序遍歷

1.對於節點P，只要左子樹不為空，就一直向左訪問，並將訪問的節點壓棧。
2.當左子樹為空時，另P指向棧頂元素的右節點並彈棧，執行步驟1。

void PreOrderNonRescursion(TreeNode *root)//虛擬碼
{
    NodeType *p=root;
    stack<NodeType*>s;
    while(NULL!=p || !s.empty())
    {
        while(NULL!=p)
        {
            s.push(p);
            visit p->val;
            p=p->left;
        }
        if
 
(!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->right;
        }
    }
}

2.2非遞迴中序遍歷

與先序遍歷類似。
1.對於節點P，只要左子樹不為空，就一直向左壓棧（但不訪問）
2.當左子樹為空時，訪問棧頂元素，並另P指向棧頂元素的右子樹，彈棧，執行步驟1。

template <typename T>
void InOrderNonRescursion(TreeNode*root)//虛擬碼
{
    NodeType *p=root;
    stack<NodeType*>s;
    while(NULL!=p || !s.empty())
    {
        while(NULL!=p)
        {
            s.push(p);
            p=p->left;
        }
        if(!s.empty())
        {
            p=s.top();
            visit p->val
            s.pop();
            p=p->right;
        }
    }
}

2.3非遞迴後序遍歷

這個就相對複雜了。要保證在訪問當前節點Cur之前，
1.要麼Cur不存在左右孩子，即左右子樹為NULL。
2.要麼Cur的左右孩子已經被訪問過了，Pre節點不為NULL且為Cur節點的左右孩子之一。

否則，如果不滿足上述條件，說明當前Cur節點的左右孩子還沒有被訪問，那麼為了保證先左子樹在右子樹的訪問順序，我們要先將右子樹壓棧，再將左子樹壓棧（如果不為空的話。）

結合上述條件有：

void Tree<T>::PostOrderNonRescursion(NodeType*root)//虛擬碼
{
    NodeType *pre=NULL;
    //NodeType *cur=root;
    NodeType *cur;
    stack<NodeType*>s;
    s.push(root);
    while( !s.empty())
    {
        cur=s.top();
        if( ((cur->left==NULL)&&(cur->right==NULL))|| //左右子樹為空
            (pre!=NULL&&(pre==cur->left||pre==cur->right)) )//或者左右子樹已被訪問
        {
            //visit cur
            s.pop();
            pre=cur;
        }
        else
        {
            if(cur->right!=NULL)
                s.push(cur->right);
            if(cur->left !=NULL)
                s.push(cur->left);
        }
    }
}

（三）二叉樹的封裝

假期無聊。想了想，就把上述三種遍歷遞迴和非遞迴形式用模板封裝了下。

3.1資料結構

//TreeNode.h

#ifndef __TREENODE_H__
#define __TREENODE_H__
#include "Tree.h"
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
template <typename T> class Tree;
template <typename T>
class TreeNode
{
    friend class Tree<T>;
    private:
        T val;
    public:
        TreeNode<T>*left;
        TreeNode<T>*right;

        TreeNode():val(0),left(NULL),right(NULL){}
        TreeNode(T x):val(x),left(NULL),right(NULL){}
};
#endif

3.2二叉樹的封裝

#ifndef __TREE_H__
#define __TREE_H__
#include "TreeNode.h"
using namespace std;

template <typename T> class TreeNode;


template  <typename T>
class Tree
{

    typedef TreeNode<T> NodeType;
    private:
        NodeType *root;
        void PreOrder_(NodeType *,vector<T>&);
        void InOrder_(NodeType *,vector<T>&);
        void PostOrder_(NodeType *,vector<T>&);
        void PreOrderNonRescursion_(NodeType *,vector<T>&);
        void InOrderNonRescursion_(NodeType *,vector<T>&);
        void PostOrderNonRescursion_(NodeType *,vector<T>&);
        void DestroyAllNode_(NodeType *);
    public:
        Tree(NodeType * r){root=r;}
        ~Tree();
        void PreOrder(vector<T>&);
        void InOrder(vector<T>&);
        void PostOrder(vector<T>&);
        void PreOrderNonRescursion(vector<T>&);
        void InOrderNonRescursion(vector<T>&);
        void PostOrderNonRescursion(vector<T>&);

};

//////////////constructor and destructor//////////////////////////////
template <typename T>
void Tree<T>::DestroyAllNode_(NodeType*root)
{
    if(root==NULL)
        return ;
    DestroyAllNode_(root->left);
    DestroyAllNode_(root->right);
    delete root;
    root=NULL;
    return ;
}

template <typename T>
Tree<T>::~Tree()
{
    DestroyAllNode_(root);
}
/////////////////PreOrder Traversal//////////////////////////////////////////////////////
template <typename T>
void Tree<T>::PreOrder_(NodeType*root,vector<T>&res)
{
    if(root==NULL)
    {
        return;
    }
    res.push_back(root->val);
    PreOrder_(root->left,res);
    PreOrder_(root->right,res);
}

template <typename T>
void Tree<T>::PreOrder(vector<T>&res)
{
    PreOrder_(root,res);
}

template <typename T>
void Tree<T>::PreOrderNonRescursion_(NodeType*root,vector<T>&res)
{
    NodeType *p=root;
    stack<NodeType*>s;
    while(NULL!=p || !s.empty())
    {
        while(NULL!=p)
        {
            s.push(p);
            res.push_back(p->val);
            p=p->left;
        }
        if(!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->right;
        }
    }
}
template <typename T>
void Tree<T>::PreOrderNonRescursion(vector<T>&res)
{
    PreOrderNonRescursion_(root,res);
}

//////////////////InOrder Traversal///////////////////////////////////////
template <typename T>
void Tree<T>::InOrder_(NodeType*root,vector<T>&res)
{
    if(root==NULL)
    {
        return;
    }
    InOrder_(root->left,res);
    res.push_back(root->val);
    InOrder_(root->right,res);
}

template <typename T>
void Tree<T>::InOrder(vector<T>&res)
{
    InOrder_(root,res);
}

template <typename T>
void Tree<T>::InOrderNonRescursion_(NodeType*root,vector<T>&res)
{
    NodeType *p=root;
    stack<NodeType*>s;
    while(NULL!=p || !s.empty())
    {
        while(NULL!=p)
        {
            s.push(p);
            p=p->left;
        }
        if(!s.empty())
        {
            p=s.top();
            res.push_back(p->val);
            s.pop();
            p=p->right;
        }
    }
}
template <typename T>
void Tree<T>::InOrderNonRescursion(vector<T>&res)
{
    InOrderNonRescursion_(root,res);
}

/////////////////PostOrder Traversal////////////////////////////////////////
template <typename T>
void Tree<T>::PostOrder_(NodeType*root,vector<T>&res)
{
    if(root==NULL)
    {
        return;
    }
    PostOrder_(root->left,res);
    PostOrder_(root->right,res);
    res.push_back(root->val);
}

template <typename T>
void Tree<T>::PostOrder(vector<T>&res)
{
    PostOrder_(root,res);
}

template <typename T>
void Tree<T>::PostOrderNonRescursion_(NodeType*root,vector<T>&res)
{
    NodeType *pre=NULL;
    //NodeType *cur=root;
    NodeType *cur;
    stack<NodeType*>s;
    s.push(root);
    while( !s.empty())
    {
        cur=s.top();
        if( ((cur->left==NULL)&&(cur->right==NULL))||
            (pre!=NULL&&(pre==cur->left||pre==cur->right)) )
        {
            res.push_back(cur->val);
            s.pop();
            pre=cur;
        }
        else
        {
            if(cur->right!=NULL)
            s.push(cur->right);
            if(cur->left !=NULL)
            s.push(cur->left);
        }
    }
}
template <typename T>
void Tree<T>::PostOrderNonRescursion(vector<T>&res)
{
    PostOrderNonRescursion_(root,res);
}

#endif

3.3測試

//main.cpp

#include "Tree.h"
int main()
{
    TreeNode<int> *root=new TreeNode<int>(0);
    root->left=new TreeNode<int>(1);
    root->right=new TreeNode<int>(2);

    Tree<int> t(root);

    vector<int>res;
    t.PreOrder(res);
    for(int i=0;i<res.size();i++)
    {
        cout << res[i];
        cout <<endl;
    }

    res.clear();
    t.PreOrderNonRescursion(res);
    for(int i=0;i<res.size();i++)
    {
        cout << res[i];
        cout <<endl;
    }

    res.clear();
    t.InOrder(res);
    for(int i=0;i<res.size();i++)
    {
        cout << res[i];
        cout <<endl;
    }

    res.clear();
    t.InOrderNonRescursion(res);
    for(int i=0;i<res.size();i++)
    {
        cout << res[i];
        cout <<endl;
    }

    res.clear();
    t.PostOrder(res);
    for(int i=0;i<res.size();i++)
    {
        cout << res[i];
        cout <<endl;
    }

    res.clear();
    t.PostOrderNonRescursion(res);
    for(int i=0;i<res.size();i++)
    {
        cout << res[i];
        cout <<endl;
    }


    return 0;
}
這裡寫圖片描述

（四）參考

相關推薦

二叉樹遍歷 C#

這就是 中序 工作 class stat public 完全 每一個 前期準備 二叉樹遍歷 C# 什麽是二叉樹 　　二叉樹是每個節點最多有兩個子樹的樹結構　　(1)完全二叉樹——若設二叉樹的高度為h，除第 h 層外，其它各層 (1～h-1) 的結

二叉樹遍歷C++（前、中、後序遍歷，層次遍歷、深度遍歷）

一.使用c++進行前中後遍歷，層次和深度遍歷（非遞迴） 二.程式碼 #include<iostream> #include<queue> #include<vector> #include<stack> using name

二叉樹遍歷c++實現

//自己還真是個菜雞，大一學了一年c++，現在還在基礎的語法上轉圈，還沒有意識到c++真正的 //的強大之處在於它的多變，封裝，等演算法告一段落了在考慮是往Java上走還是深造c++ #include <iostream> #include <stack&

二叉樹遍歷C++程式碼

/***********************二叉樹遍歷*********************/ #include <iostream> using namespace std; template<class Type> cla

二叉樹遍歷-c實現

bin lib malloc code mage -a oid inf 樹遍歷 這裏主要是三種遍歷，先序（preorder，NLR），中序（Inorder，LNR），後序（Postorder，LRN） N：node，L：left，R：right 基本排序：先序（NLR，

二叉樹的遍歷 C++模板+封裝

二叉樹的遍歷主要是前序、中序和後序遍歷（還有層序遍歷，參見：層序遍歷） （一）遞迴形式 這三種遍歷訪問順序分別為： 前序：根->左子樹->右子樹 中序：左子樹->根->右子樹 後序：左子樹->右子樹->

二叉樹——遍歷篇（c++）

比較 方便 || 遍歷二叉樹 找到 保存 們的 order out 二叉樹——遍歷篇 二叉樹很多算法題都與其遍歷相關，筆者經過大量學習並進行了思考和總結，寫下這篇二叉樹的遍歷篇。 1、二叉樹數據結構及訪問函數 #include <stdio.h> #includ

c++實現二叉樹層序、前序創建二叉樹，遞歸非遞歸實現二叉樹遍歷

log ios cst ack ret 出棧 隊列 結點 非遞歸實現 #include <iostream> #include <cstdio> #include <stdio.h> #include <string> #i

二叉樹遍歷（C++實現）

二叉樹3種深度優先遍歷（遞迴、非遞迴）、層次遍歷，最簡潔、最好記！ #include<iostream> #include<stack> #include<queue> using namespace std; //節點定義 struct Node { c

[二叉樹] 遍歷方法總結--遞迴與非遞迴--純C實現

非遞迴方法： 思路一：根據訪問次序來入棧並輸出 思路二：模擬訪問過程 思路三：使用識別符號mark來記錄已經第幾次訪問該結點 /* @Desc:二叉連結串列 無頭結點 @Vesrion:0.0.1 @Time:20180922建立 */ #include

二叉樹遍歷 遞迴/非遞迴 模板（？？）

遞迴版 void First_order_traversal(int i) //先序 { printf("%d\n", key[i]); First_order_traversal(lc[i]);

二叉樹遍歷模板以及一些例子

//二叉樹三種遍歷模板（本文直接摘自天勤考研資料結構第六章） void Travel(BTNode *p) {     if (p != NULL)     {         //(1)         Travel(p->lchild);         //(2

二叉樹遍歷非遞迴寫法c++

1、前序遍歷 /* 將根節點壓棧，（棧先進後出） 然後對於棧頂節點，先輸出棧頂節點的值， 然後把右孩子壓棧，再把左孩子壓棧。 對應於先序遍歷的先遍歷父節點，再遍歷左節點再遍歷右節點的順序 */ void preOrderRecursion(treeNode

二叉樹遍歷的c++具體實現

樹的資料結構如下： struct TreeNode{ int val; TreeNode* left; TreeNode* right; };一、先序遍歷 按照“根結點-左孩

【C++】非遞迴的三種二叉樹遍歷

 二叉樹的遍歷有三種方式，如下： （1）前序遍歷（DLR），首先訪問根結點，然後遍歷左子樹，最後遍歷右子樹。簡記根-左-右。 （2）中序遍歷（LDR），首先遍歷左子樹，然後訪問根結點，最後遍歷右子樹。簡記左-根-右。 （3）後序遍歷（LRD），首先遍歷左子樹，然後遍歷右

（C語言版）二叉樹遍歷演算法——包含遞迴前、中、後序和層次，非遞迴前、中、後序和層次遍歷共八種

#include <stdlib.h> #include <stdio.h> #include "BiTree.h" #include "LinkStack.h" #include "LinkQueue.h" //初始化二叉樹（含根節點） void InitBiTree(pBiTr

c語言使用指標實現二叉樹遍歷

使用指標實現二叉樹的定義，建立，以及前序遍歷，中序遍歷，後續遍歷。 /* 該程式實現了二叉樹的建立，以及樹的遍歷，前序遍歷，中序遍歷，後序遍歷。 */ #include <stdio.h> #include<stdlib.h> #include &

C語言二叉樹 遍歷目錄樹

#include "stdio.h"#include "windows.h"#include <iostream>using namespace std;unsigned long sum = 0;//////////////////////////////////////////////////

非遞迴實現二叉樹遍歷（附c++完整程式碼）

先序、中序和後序遍歷過程：遍歷過程中經過結點的路線一樣，只是訪問各結點的時機不同。 從圖中可以看到，前序遍歷在第一次遇見元素時輸出，中序遍歷在第二次遇見元素時輸出，後序遍歷在第三次遇見元素時輸出。 非遞迴演算法實現的基本思路：使用堆疊 一、前序遍歷 1、遞迴實

第九周專案三C/C++利用二叉樹遍歷思想解決問題

/* *Copyright (c) 2017,煙臺大學計算機與控制工程學院 *All rights reserved. *檔名稱：.cpp *完成日期：2017年11月16日 *版 本 號：v1.0 * 利用二叉樹遍歷思想解決問題 /* 【利