二叉树是一种树形结构,它的特点是每个分支点嘴都只有2棵子树,在离散中称为2元树,当每个分支点(叶不是分支点)都有2个儿子时称为k元完全树。二叉树通常用做二叉查找树和二叉堆。
头文件:
/**********************
The BinaryTree head file
Created by SKY_TM on 2015/1/27
**********************/
#pragma once
#include <iostream>
using namespace std;
class TreeNode
{
friend class BinaryTree;
public :
//重载输出操作符
friend ostream &operator << (ostream &os, const TreeNode &node)
{
os << node.m_keyValue;
return os;
}
TreeNode(int keyValue = 0, TreeNode *leftChild = nullptr, TreeNode *rightChild = nullptr)
: m_keyValue(keyValue), m_leftChild(leftChild), m_rightChild(rightChild)
{
}
TreeNode(const TreeNode &t)
: m_keyValue(t.m_keyValue), m_leftChild(t.m_leftChild), m_rightChild(t.m_rightChild)
{
}
virtual ~TreeNode()
{
}
public :
TreeNode *m_leftChild;
TreeNode *m_rightChild;
private :
int m_keyValue;
};
//BinaryTree
class BinaryTree
{
public :
BinaryTree(TreeNode *rootNode = nullptr)
:m_rootNode(rootNode)
{
}
BinaryTree(const int keyValue)
{
m_rootNode = new TreeNode(keyValue);
}
BinaryTree(const BinaryTree &BnrTree);
virtual ~BinaryTree()
{
}
public :
//三种遍历的顺序就是根被访问的位置在前面,在后面,还是在中间的问题
void PreOrderTraverse(const TreeNode *const &node);//先序遍历
void InOrderTraverse(const TreeNode *const &node);//中序遍历
void PostOrderTraverse(const TreeNode *const &node);//后序遍历
void Insert(const int &keyValue);//插入
void Insert(TreeNode *&child);
TreeNode *Copy(const TreeNode *const &oldNode);//深拷贝,拷贝这个动作无需改变oldNode的内容所以声明为const
TreeNode *Search(const int keyValue);//查找
TreeNode *GetRootNode();//获取整棵树的根节点
void Visit(const TreeNode *const T);//打印节点中的内容
void Destroy(TreeNode *node);//删除节点
private :
void Insert(TreeNode *&root, const int &keyValue);
void Insert(TreeNode *&root, TreeNode *&child);
TreeNode *Search(const int keyValue, TreeNode *&root);
public :
static TreeNode *Create(const int keyValue);//静态类构造函数,返回根节点.
private :
TreeNode *m_rootNode;
};
下面是BinaryTree.h的实现文件:
/********************************
BinaryTree's completed file
Created by SKY-TM on 2015/1/27
********************************/
#include "BinaryTree.h"
//return the root node
TreeNode *BinaryTree::Create(const int keyValue)
{
return new TreeNode(keyValue);
}
BinaryTree::BinaryTree(const BinaryTree &BnrTree)
{
if(BnrTree.m_rootNode != nullptr)
{
m_rootNode = Copy(BnrTree.m_rootNode);
}
else
{
m_rootNode = nullptr;
}
}
void BinaryTree::Insert(const int &keyValue)
{
if(m_rootNode != nullptr)
{
Insert(m_rootNode, keyValue);
}
else
{
m_rootNode = new TreeNode(keyValue);
}
}
void BinaryTree::Insert(TreeNode *&child)
{
if(m_rootNode != nullptr)
{
Insert(m_rootNode, child);
}
else
{
m_rootNode = child;
}
}
void BinaryTree::Insert(TreeNode *&root, const int &keyValue)
{
if(root != nullptr)
{
if(keyValue < root->m_keyValue)
{
Insert(root->m_leftChild, keyValue);
}
else
{
Insert(root->m_rightChild, keyValue);
}
}
else
{
root = new TreeNode(keyValue);
}
}
void BinaryTree::Insert(TreeNode *&root, TreeNode *&child)
{
if(root != nullptr)
{
if(child->m_keyValue < root->m_keyValue)
{
Insert(root->m_leftChild, child);
}
else
{
Insert(root->m_rightChild, child);
}
}
else
{
root = child;
}
}
TreeNode *BinaryTree::Copy(const TreeNode *const &oldNode)
{
if(oldNode != nullptr)
{
TreeNode *newNode = new TreeNode(oldNode->m_keyValue);
newNode->m_leftChild = Copy(oldNode->m_leftChild);
newNode->m_rightChild = Copy(oldNode->m_rightChild);
return newNode;
}
return nullptr;
}
TreeNode * BinaryTree::Search(const int keyValue)
{
return Search(keyValue, m_rootNode);
}
TreeNode *BinaryTree::Search(const int keyValue, TreeNode *&root)
{
if(keyValue == root->m_keyValue)
{
return root;
}
else if(keyValue < root->m_keyValue)
{
return Search(keyValue, root->m_leftChild);
}
else if(keyValue > root->m_keyValue)
{
return Search(keyValue, root->m_rightChild);
}
return nullptr;
}
void BinaryTree::Visit(const TreeNode *const T)
{
cout << *T << " ";
}
void BinaryTree::PreOrderTraverse(const TreeNode *const &node)
{
if(node != nullptr)
{
Visit(node);
PreOrderTraverse(node->m_leftChild);
PreOrderTraverse(node->m_rightChild);
}
}
void BinaryTree::InOrderTraverse(const TreeNode *const &node)
{
if(node != nullptr)
{
InOrderTraverse(node->m_leftChild);
Visit(node);
InOrderTraverse(node->m_rightChild);
}
}
void BinaryTree::PostOrderTraverse(const TreeNode *const &node)
{
if(node != nullptr)
{
PostOrderTraverse(node->m_leftChild);
PostOrderTraverse(node->m_rightChild);
Visit(node);
}
}
TreeNode *BinaryTree::GetRootNode()
{
return m_rootNode;
}
void BinaryTree::Destroy(TreeNode *node)
{
if(node != nullptr)
{
Destroy(node->m_leftChild);
Destroy(node->m_rightChild);
delete node;
}
return ;
}
再来就是main.cpp,作为测试:
/*********************
main.cpp
*********************/
#include "BinaryTree.h"
int main()
{
BinaryTree *bTree = new BinaryTree();
int a[7] = {10, 6, 5, 8, 14, 11, 18};
for(int i = 0; i < 7; ++i)
{
bTree->Insert(a[i]);
}
if(bTree->Search(11) != nullptr)
{
cout << *bTree->Search(11) << endl;
}
bTree->PreOrderTraverse(bTree->GetRootNode());
cout << endl;
bTree->InOrderTraverse(bTree->GetRootNode());
cout << endl;
bTree->PostOrderTraverse(bTree->GetRootNode());
cout << endl;
BinaryTree bTree2 = *bTree;
bTree2.PreOrderTraverse(bTree2.GetRootNode());
cout << endl;
bTree->Destroy(bTree->GetRootNode());
bTree2.Destroy(bTree2.GetRootNode());
system("PAUSE");
return 0;
}
这样一棵二叉查找树的创建和查找和遍历都有了。0-0