2. 程式人生 > >C++資料結構之 --二叉樹簡單實現和4種遍歷

C++資料結構之 --二叉樹簡單實現和4種遍歷

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

實驗目的：實現簡單的二叉樹！

標頭檔案：

二叉樹.h

#ifndef 二叉樹_h__
#define 二叉樹_h__

#include <iostream>
#include <queue>
template<class T> class BinaryTree;//二叉樹的宣告
/*樹的節點*/
template<class T>
class TreeNode{
public:
 TreeNode<T> *leftChild;
 TreeNode<T> *rightChild;
 T data;
public: 
 TreeNode(){
  leftChild = NULL;
  rightChild = NULL;
 }

};

//二叉樹的定義
template<class T>
class BinaryTree{
public:
 TreeNode<T> *root;//頭節點
public:
 void InOrder();//中序遍歷
 void InOrder(TreeNode<T> *currentNode);

 void PreOrder();//先序遍歷
 void PreOrder(TreeNode<T> *currentNode);

 void EndOrder();//後序遍歷
 void EndOrder(TreeNode<T> *currentNode);

 void LevelOrder();//層序遍歷
 void LevelOrder(TreeNode<T> *currentNode);

 void Visit(TreeNode<T> *currentNode);//訪問當前節點
};

template<class T>
void BinaryTree<T>::LevelOrder(){
 std::cout << "層序遍歷:" << std::endl;
 LevelOrder(root);
}
template<class T>
void BinaryTree<T>::LevelOrder(TreeNode<T> *currentNode){
 //建立一個佇列
 std::queue<TreeNode<T>*> q;

 while(currentNode)
 {
  Visit(currentNode);
  if (currentNode->leftChild)
  {
   q.push(currentNode->leftChild);
  }
  if (currentNode->rightChild)
  {
   q.push(currentNode->rightChild);
  }
  if (q.empty())
  {
   return;
  }
  //在彈出一個節點時，我們要先把它的左右孩子先放進佇列裡
  currentNode = q.front();//取隊首的節點，
  q.pop();
 }
}
template<class T>
void BinaryTree<T>::Visit(TreeNode<T> *currentNode){
 std::cout << currentNode->data << " ";
}

template<class T>
void BinaryTree<T>::EndOrder(){
 std::cout << "後序遍歷:" << std::endl;
 EndOrder(root);
}

template<class T>
void BinaryTree<T>::EndOrder(TreeNode<T> *currentNode)
{
 if (currentNode)
 {
  EndOrder(currentNode->leftChild);
  EndOrder(currentNode->rightChild);
  Visit(currentNode);
 }
}

template<class T>
void BinaryTree<T>::PreOrder(){
 std::cout << "先序遍歷:" << std::endl;
 PreOrder(root);
}
template<class T>
void BinaryTree<T>::PreOrder(TreeNode<T> *currentNode){
 if (currentNode)
 {
  Visit(currentNode);
  PreOrder(currentNode->leftChild);
  PreOrder(currentNode->rightChild);
 }
}
template<class T>
void BinaryTree<T>::InOrder(){
 std::cout << "中序遍歷:" << std::endl;
 InOrder(root);
}
template<class T>
void BinaryTree<T>::InOrder(TreeNode<T> *currentNode){
 if (currentNode)
 {
  InOrder(currentNode->leftChild);
  //顯示當前節點
  Visit(currentNode);
  InOrder(currentNode->rightChild);
 }
}
#endif // 二叉樹_h__

/* 遍歷的規則：
中序遍歷：左子樹-節點-右子樹
先序遍歷：節點-左子樹-右子樹
後序遍歷：左子樹-右子樹-節點

層序遍歷：一層一層遍歷
*/

實驗的二叉樹圖

原始檔

main.cpp

#include <iostream>
#include "二叉樹.h"
using namespace std;
int main(int argc,const char* argv[]){
 cout << "你好，每一天" << endl;
 /*構造二叉樹*/
 TreeNode<int> a1;
 a1.data = 1;
 TreeNode<int> b2;
 b2.data = 2;
 TreeNode<int> c3;
 c3.data = 3;
 TreeNode<int> d4;
 d4.data = 4;
 TreeNode<int> e5;
 e5.data = 5;
 TreeNode<int> f6;
 f6.data = 6;
 TreeNode<int> g7;
 g7.data = 7;
 TreeNode<int> h8;
 h8.data = 8;
 TreeNode<int> i9;
 i9.data = 9;

 /*建立二叉樹*/
 BinaryTree<int> binaryTree;
 binaryTree.root = &a1;

 a1.leftChild = &b2;
 a1.rightChild = &c3;

 b2.leftChild = &d4;
 b2.rightChild = &e5;

 e5.leftChild = &g7;
 e5.rightChild = &h8;

 c3.leftChild = &f6;
 f6.rightChild = &i9;
 
 
 /*先序遍歷*/
 binaryTree.PreOrder();
 cout <<endl;
 /*中序遍歷*/
 binaryTree.InOrder();
 cout <<endl;
 /*後序遍歷*/
 binaryTree.EndOrder();
 cout << endl;
 /*層序遍歷*/
 binaryTree.LevelOrder();
 system("pause");
 return 0;
}

實驗結果：

總結：

二叉樹：只要有頭節點（root），就可以確定一個二叉樹了。

節點：每一個節點，都有  value，leftfchild,rightchild.

層序遍歷時需要藉助佇列。

第二篇：二叉樹的簡單實現和4種遍歷操作

#pragma once
#ifndef NODE_H
#define NODE_H
class Node
{
public:
 friend class BinaryTree;
 Node();
 Node(int item);
 ~Node();
 //設定Value
 void setData(int item);
 int getData();
 //設定leftChild
 void setLeft(Node* left);
 Node* getLeft();
 //設定rightChild
 void setRight(Node* right);
 Node* getRight();
private:
 Node* left;
 Node* right;
 int data;
};

#endif

#include "Node.h"
Node::Node(){}

Node::Node(int item)
{
 this->data = item;
 this->left = nullptr;
 this->right = nullptr;
}

Node::~Node(){}

void Node::setData(int item){
 this->data = item;
}
int Node::getData(){
 return this->data;
}
void Node::setLeft(Node* left){
 this->left = left;
}
Node* Node::getLeft(){
 return this->left;
}
void Node::setRight(Node* right){
 this->right = right;
}
Node* Node::getRight(){
 return this->right;
}

#pragma once
#ifndef BinaryTree_h__
#define BinaryTree_h__
#include "Node.h"
class BinaryTree
{
public:
 //構造器
 BinaryTree();
 ~BinaryTree();
 //獲取根節點
 Node* getRoot();
 //建立一棵二叉樹
 void CreatBinaryTree();
 //新增節點函式
 void addNode(Node* newNode,Node* itemroot);
 //先根遍歷
 void preOrder(Node* t);
 //中根遍歷
 void inOrder(Node* t);
 //後根遍歷
 void postOrder(Node* t);
 //層序遍歷
 void levelOrder(Node* t);
 //尋找data為item的節點
 Node* findData(Node* t, int item);
 //尋找給定節點的父節點
 Node* returnFather(Node* t, Node *p);
 //刪除t節點及其左右子樹
 void deleteSubTree(Node* t);
private:
 //判斷新增節點是否比根小
 bool toLeft(int a, int b);
 //判斷新增的節點是否比根大
 bool toRight(int a, int b);
 //刪除節點和節點的左右子樹
 void deletAll(Node* t);
 
 //頭節點
 Node* root;
   


 
};


#endif // BinaryTree_h__

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

BinaryTree::BinaryTree(){ root = nullptr; }

BinaryTree::~BinaryTree(){}

//獲取根節點
Node* BinaryTree::getRoot(){  return root; }
void BinaryTree::CreatBinaryTree() //建立一棵二叉樹
{
 cout << "以此輸入number（按“字母”退出）" << endl;
 int intValue;
 Node* current;
 while (cin >> intValue)
 {
  current = new Node(intValue);//構造新的節點
  if (root==nullptr)
   root = current;
  else
   addNode(current,root);
 }
}
//新增節點函式
void BinaryTree::addNode(Node* newNode, Node* root)
{
 //判斷是否新增到左子樹
 if (toLeft(newNode->data, root->data))
 {
  if (root->left == nullptr)
  {
   root->left = newNode;
  }
  else
  {
   addNode(newNode, root->left);
  }

 }
 else if (toRight(newNode->data, root->data))
 {
  if (root->right == nullptr)
  {
   root->right = newNode;
  }
  else
  {
   addNode(newNode, root->right);
  }
 }
}
void BinaryTree::preOrder(Node* t)//先根遍歷
{
 if (t!=nullptr)
 {
  cout << t->getData() <<"  ";
  preOrder(t->getLeft());
  preOrder(t->getRight());
 }
}
void BinaryTree::inOrder(Node* t)//中根遍歷
{
 if (t!=nullptr)
 {
  inOrder(t->getLeft());
  cout << t->getData() << "  ";
  inOrder(t->getRight());
 }
}
void BinaryTree::postOrder(Node* t)//後根遍歷
{
 if (t!=nullptr)
 {
  postOrder(t->getLeft());
  postOrder(t->getRight());
  cout << t->getData() << "  ";
 }
}

//層序遍歷
void BinaryTree::levelOrder(Node* t){
 //先建立一個佇列
 queue<Node*> myQueue;
 while (t!=nullptr)
 {
  cout << t->data << "  ";//先列印它的值
  //把左孩子放進去
  if (t->left!=nullptr)
  {
   myQueue.push(t->left);
  }
  //把有孩子放進去
  if (t->right!=nullptr)
  {
   myQueue.push(t->right);
  }
  if (myQueue.empty())
  {
   return;
  }
  //獲取當前的節點
  t = myQueue.front();
  
  myQueue.pop();

 }
}
//尋找data為item的節點
Node* BinaryTree::findData(Node* t, int item)
{
 Node* p;
 if (t==nullptr)
 {
  return nullptr;
 }else if (t->getData()==item)
 {
  return t;
 }else if ((p=findData(t->getLeft(),item))!=nullptr)
 {
  return p;
 }
 else
 {
  return findData(t->getRight(), item);
 }
}
//尋找給定節點的父節點
Node* BinaryTree::returnFather(Node* t, Node *p)
{
 Node* q;
 if (t==nullptr || p==nullptr)
 {
  return nullptr;
 }
 else if (t->getLeft()==p || t->getRight()==p)
 {
  return t;
 }else if ((q=returnFather(t->getLeft(),p))!=nullptr)
 {
  return q;
 }
 else
 {
  return returnFather(t->getRight(),p);
 }
}
//刪除t節點及其左右子樹
void BinaryTree::deleteSubTree(Node* t)
{
 if (t==nullptr)
 {
  return;
 }else if (t==root)
 {
  deletAll(t);
  root = nullptr;
  return;
 }
 Node* p, *q;
 p = t;
 q = returnFather(root, p);
 if (q)
 {
  if ((q->getLeft())==p)
  {
   q->setLeft(nullptr);
  }
  else
  {
   q->setRight(nullptr);
  }
 }
 deletAll(p);
}
//判斷新增節點是否比根小
bool BinaryTree::toLeft(int newItemValue, int rootValue)
{
 if (newItemValue<rootValue)
 {
  return true;
 }
 else
 {
  return false;
 }
}
//判斷新增的節點是否比根大
bool BinaryTree::toRight(int newItemValue, int rootValue)
{
 if (newItemValue>rootValue)
 {
  return true;
 }
 else
 {
  return false;
 }
}
//無情幹掉子節點和左右子樹
void BinaryTree::deletAll(Node* t)
{
 if (t!=nullptr)
 {
  deletAll(t->getLeft());
  deletAll(t->getRight());
  delete t;
 }
}

#include <iostream>
#include "BinaryTree.h"
using namespace std;
int main(){
 BinaryTree binaryTree;
 binaryTree.CreatBinaryTree();
 cout << "先序遍歷結果:" <<" ";
 binaryTree.preOrder(binaryTree.getRoot());
 cout << endl;
 cout << "中序遍歷結果:" << " ";
 binaryTree.inOrder(binaryTree.getRoot());
 cout << endl;
 cout << "後序遍歷結果:" << " ";
 binaryTree.postOrder(binaryTree.getRoot());
 cout << endl;
 cout << "層序遍歷結果:" << " ";
 binaryTree.levelOrder(binaryTree.getRoot());
 cout << endl;
    Node* test;
 test = binaryTree.findData(binaryTree.getRoot(), 2);
 Node* test2;
 test2 = binaryTree.returnFather(binaryTree.getRoot(), test);
 cout << test2->getData() << endl;
 binaryTree.deleteSubTree(test);
    cout << "刪除後中根遍歷結果：" << " ";
 binaryTree.inOrder(binaryTree.getRoot());
 cout << endl;

 system("pause");
 return 0;
}


 

相關推薦

C++資料結構之 --二叉樹簡單實現和4種遍歷

實驗目的：實現簡單的二叉樹！ 標頭檔案： 二叉樹.h #ifndef 二叉樹_h__ #define 二叉樹_h__ #include <iostream> #include <q

java資料結構與之二叉樹相關實現(第一篇：遍歷)

一、基本概念 每個結點最多有兩棵子樹，左子樹和右子樹，次序不可以顛倒。 性質： 非空二叉樹的第n層上至多有2^(n-1)個元素。 深度為h的二叉樹至多有2^h-1個結點。 滿二叉樹：所有終端都在同一層次，且非終端結點的度數為2。 在滿二叉

C++資料結構--計算二叉樹葉子數和深度

1.示例二叉樹   2.計算二叉樹深度：     *先計算左右子樹的深度，然後整棵樹的深度就是左右子樹深度較大值加1     *遞迴遍歷結束條件：定義空樹的深度為-1，於是得到葉子節點的深度計算公式       Depth(葉節點）= 1 + max(depth(左子樹），depth(右子樹））      

資料結構之 二叉樹的儲存和遍歷總結

知道前序（包括空結點 下面程式碼用’,’代替）建立一個二叉樹，前序 中序 後序 層序輸出 如何求葉子結點數， 如何求二叉樹深度。 #include<stdio.h> #include<stdlib.h> #include<st

遞迴和非遞迴實現二叉樹的建立和三種遍歷

#include<stdio.h> #include<stdlib.h> #define SIZE 2

C Primer Plus--高階資料結構之二叉樹

目錄 二叉搜尋樹 Binary Search Tree 用C構建二叉樹ADT 樹結構的定義 C Primer Plus--高階資料結構表示之二叉樹 二叉搜尋樹 Binary Search Tree 二叉樹是一種高階資料結構。樹中的每個節點都包含一個專案和兩個指向其他

資料結構之---二叉樹C實現

學過資料結構的都知道樹，那麼什麼是樹？ 樹（tree）是包含n（n>0）個結點的有窮集，其中： （1）每個元素稱為結點（node）； （2）有一個特定的結點被稱為根結點或樹根（root）。 （3）除根結點之外的其餘資料元素被分為m（m≥0）個互不相交的集合

資料結構之二叉樹應用（哈夫曼樹及哈夫曼編碼實現）（C++）

一、哈夫曼樹1.書上用的是靜態連結串列實現，本文中的哈夫曼樹用 排序連結串列 實現；2.實現了從 字元頻率統計、構建權值集合、建立哈夫曼樹、生成哈夫曼編碼，最後對 給定字串的編碼、解碼功能。3.使用到的 “SortedList.h”標頭檔案，在上篇博文：資料結構之排序單鏈表。

今日分資料結構作業:二叉樹簡單操作

又是一次非常有趣(sangxinbingkuang)的作業。 這麼簡單的作業居然寫了一下午，我也是醉了。 看來下次要調整好狀態再寫作業了QAQ。 先看實驗要求： 後三道題懶得寫了，就不發要求了/滑稽。 程式碼(附帶詳細註釋)： import java.util.*;

C++資料結構 16 二叉樹

樹集成了陣列和連結串列的優點（查詢速度快） 樹：結點，度，葉結點，父結點，子結點，兄弟結點，樹的度，樹的高度。 具體概念可以參考：https://blog.csdn.net/u012928324/article/details/61194190?utm_source=itdadao&am

python資料結構之二叉樹

這裡用python 實現了二叉樹 # Definition for a binary tree node. class TreeNode: def __init__(self, x): self.val = x self.left =

資料結構之二叉樹

二叉樹的性質 在二叉樹的第iii層上至多有2i−12^{i-1}2i−1個結點(i≥1)(i \geq 1)(i≥1)。 深度為kkk的二叉樹至多有2k−12^{k}-12k−1個結點(k≥1)(k\geq 1)(k≥1)。 對任何一棵二叉樹TTT，如果其終端

Python3&資料結構之二叉樹

實現二叉樹以及遍歷 在電腦科學中，二叉樹是每個結點最多有兩個子樹的樹結構。通常子樹被稱作“左子樹”（left subtree）和“右子樹”（right subtree）。二叉樹常被用於實現二叉查詢樹和二叉堆。   二叉樹是遞迴定義的，其結點有左右子樹之分，邏輯上二叉樹有五種基本

資料結構之二叉樹基本功能的實現

二叉樹的各種性質在這裡不再重複，本文實現二叉樹的基本操作，包括建立、前序輸出、中序輸出、後序輸出、刪除二叉樹、葉子結點個數、葉子節點的值、交換左右子樹 1.首先建立結構體： typedef struct Tree_Node{ char ch; struct

Ikaros的資料結構之二叉樹（基礎概念部分）

二叉樹（Binary Tree） 在瞭解二叉樹之前你需要了解如下內容： 1.樹（Tree）：是一種非線性資料結構（非線性資料結構包含樹和圖） ①樹的資料結構： 相關術語 a.根節點（root）：樹中沒有前驅的結點 注：一棵樹中只有一個根節點 b.葉子結點（le

資料結構之"二叉樹的三種遍歷方法"

1、什麼是二叉樹 定義：有且僅有一個根節點，每個節點只有一個父節點，最多含有兩個子節點，子節點有左右之分。 2、二叉樹的遍歷 二叉樹是一種樹形結構，遍歷就是要讓樹中的節點被且僅被訪問一次，即按一定規律排列成一個線性佇列。二叉樹是一種遞迴定義的結構，包含三個部分：根節點（

【資料結構之二叉樹】（一）B樹、B-樹、B+樹、B*樹介紹，和B+樹更適合做檔案索引的原因

     今天看資料庫，書中提到：由於索引是採用 B 樹結構儲存的，所以對應的索引項並不會被刪除，經過一段時間的增刪改操作後，資料庫中就會出現大量的儲存碎片，這和磁碟碎片、記憶體碎片產生原理是類似的，這些儲存碎片不僅佔用了儲存空間，而且降低了資料庫執行的速度。如果發現索引

【資料結構之二叉樹】（二）B+樹比B樹更適合做檔案索引的原因

 原因：相對於B樹， （1）B+樹空間利用率更高，可減少I/O次數， 一般來說，索引本身也很大，不可能全部儲存在記憶體中，因此索引往往以索引檔案的形式儲存的磁碟上。這樣的話，索引查詢過程中就要產生磁碟I/O消耗。而因為B+樹的內部節點只是作為索引使用，而不像B-樹那樣每個節點都需要儲存硬碟指標。

資料結構之二叉樹的遍歷：

一.二叉樹—特殊樹（基礎知識） （一）概念： 一個二叉樹要麼為空，要麼包含一個根節點，外加一個左子樹和右子樹，每一個字數都是二叉樹 (二)二叉樹的形狀： 不平衡二叉樹、完美平衡二叉樹、完全二叉樹、滿二叉樹； 一般來說二叉樹越平衡，訪問、插入、刪除的效能也越高； （三）二叉樹的遍歷; 1,前序

C++資料結構：二叉樹（一）——先序建立二叉樹

一、二叉樹 （Binary Tree） 定義： 二叉樹是n個節點的有限集合，該集合或者為空集（ 稱為空二叉樹 ），或者由一個根節點和兩棵互不相交的的二叉樹組成，這兩棵二叉樹分別稱為根節點的左子樹和右