数据结构学习五：二叉树

二叉树

          二叉树是一棵树，其中每个节点的孩子最多为2个。性质：平均二叉树的深度要比节点数N小得多，对于特殊类型的二叉树，即二叉查找树其深度的平均值是O(logN)。

实现

       因为二叉树最多有两个孩子，所以可以定义两个指针指向他们。二叉树的声明在结构上类似于双链表的声明。

定义如下

/*
* 二叉树声明
*/
struct TreeNode
{
int Data;
TreeNode* Left;
TreeNode* Right;
};

下面以二叉查找树的实现举例
#pragma once
#include"TreeNode.h"

/*
*二叉查找树
*/
class BinarySearchTree
{
private:
TreeNode* _root;
public:
BinarySearchTree();
~BinarySearchTree();

public:
void MakeEmpty();
TreeNode* FindData(int data, TreeNode* t);
TreeNode* FindMin(TreeNode* t);
TreeNode* FindMax(TreeNode* t);
bool Insert(int data);
bool Delete(int data);
void ShowTree();
private:
TreeNode* Find(int data);
void MakeEmptyTree(TreeNode* t);
TreeNode* SubInsert(int data, TreeNode* t);
TreeNode* SubDelete(int data, TreeNode* t);

/*print tree*/
void PrintBinaryTree(TreeNode *root);
void PrintNode(vector<TreeNode*> &nodes, int level, int max_level);
void PrintWhiteSpaces(int num);
bool IsAllElementsNULL(const vector<TreeNode*> &nodes);
int MaxLevel(TreeNode *root);
int max(int a, int b);
};

#include "stdafx.h"
#include "BinarySearchTree.h"

BinarySearchTree::BinarySearchTree()
{
}

BinarySearchTree::~BinarySearchTree()
{
}

void BinarySearchTree::MakeEmpty()
{
if (_root != nullptr)
{
MakeEmptyTree(_root);
}
return;
}

TreeNode* BinarySearchTree::FindData(int data,TreeNode* t)
{
if (t == nullptr)
{
return nullptr;
}
if (data < t->Data)
{
return FindData(data, t->Left);
}
else if (data > t->Data)
{
return FindData(data, t->Right);
}
else
{
return t;
}
}

TreeNode* BinarySearchTree::FindMin(TreeNode* t)
{
if (t == nullptr)
{
return nullptr;
}
else if (t->Left == nullptr)
{
return t;
}
else
{
return FindMin(t->Left);
}
}

TreeNode* BinarySearchTree::FindMax(TreeNode* t)
{
if (t != nullptr)
{
while (t->Right != nullptr)
{
t = t->Right;
}
}
return t;
}

bool BinarySearchTree::Insert(int data)
{
_root=SubInsert(data, _root);
if (nullptr == _root)
{
return false;
}
return true;
}

bool BinarySearchTree::Delete(int data)
{
if (_root == nullptr)
{
return false;
}
_root=SubDelete(data, _root);
return true;
}

void BinarySearchTree::ShowTree()
{
PrintBinaryTree(_root);
}

TreeNode * BinarySearchTree::Find(int data)
{
return nullptr;
}

void BinarySearchTree::MakeEmptyTree(TreeNode * t)
{
if (t != nullptr)
{
MakeEmptyTree(t->Left);
MakeEmptyTree(t->Right);
delete t;
}
}

TreeNode* BinarySearchTree::SubInsert(int data, TreeNode * t)
{
if (nullptr == t)
{
t = new TreeNode();
if (nullptr == t)
{
return nullptr;
}
else
{
t->Data = data;
t->Left = t->Right = nullptr;
}
}
else if (data < t->Data)
{
t->Left = SubInsert(data, t->Left);
}
else if (data > t->Data)
{
t->Right = SubInsert(data, t->Right);
}
return t;
}

TreeNode * BinarySearchTree::SubDelete(int data, TreeNode * t)
{
TreeNode* tempCell;
if (t == nullptr)
{
return nullptr;
}
else if (data < t->Data)
{
t->Left = SubDelete(data, t->Left);
}
else if (data > t->Data)
{
t->Right = SubDelete(data, t->Right);
}
else if (t->Left && t->Right)
{
tempCell = FindMin(t->Right);
t->Data = tempCell->Data;
t->Right = SubDelete(t->Data, t->Right);
}
else
{
tempCell = t;
if (t->Left == nullptr)
{
t = t->Right;
}
else if (t->Right == nullptr)
{
t = t->Left;
}
delete tempCell;
}
return t;
}

#pragma region print binary tree
/* print binary tree*/
// wrapper function
void BinarySearchTree::PrintBinaryTree(TreeNode *root)
{
int max_level = MaxLevel(root);
vector<TreeNode*> nodes;

nodes.push_back(root);

PrintNode(nodes, 1, max_level);
}

int BinarySearchTree::MaxLevel(TreeNode *root)
{
if (root == NULL) return 0;
return max(MaxLevel(root->Left), MaxLevel(root->Right)) + 1;
}

void BinarySearchTree::PrintNode(vector<TreeNode*> &nodes, int level, int max_level)
{
if (nodes.empty() || IsAllElementsNULL(nodes)) return; // exit

int floor = max_level - level;
int endge_lines = 1 << (max(floor - 1, 0));
int first_spaces = (1 << floor) - 1;
int between_spaces = (1 << (floor + 1)) - 1;

PrintWhiteSpaces(first_spaces);

// print the 'level' level
vector<TreeNode*> new_nodes;
vector<TreeNode*>::const_iterator it = nodes.begin();
for (; it != nodes.end(); ++it) {
if (*it != NULL) {
cout << (*it)->Data;
new_nodes.push_back((*it)->Left);
new_nodes.push_back((*it)->Right);
}
else {
new_nodes.push_back(NULL);
new_nodes.push_back(NULL);
cout << " ";
}
PrintWhiteSpaces(between_spaces);
}
cout << endl;

// print the following /s and \s
for (int i = 1; i <= endge_lines; ++i) {
for (int j = 0; j<nodes.size(); ++j) {
PrintWhiteSpaces(first_spaces - i);
if (nodes[j] == NULL) {
PrintWhiteSpaces(endge_lines + endge_lines + i + 1);
continue;
}
if (nodes[j]->Left != NULL)
cout << "/";
else
PrintWhiteSpaces(1);

PrintWhiteSpaces(i + i - 1);

if (nodes[j]->Right != NULL)
cout << "\\";
else
PrintWhiteSpaces(1);

PrintWhiteSpaces(endge_lines + endge_lines - i);
}
cout << endl;
}

PrintNode(new_nodes, level + 1, max_level);

}

// test whether all elements in vector are NULL
bool BinarySearchTree::IsAllElementsNULL(const vector<TreeNode*> &nodes)
{
vector<TreeNode*>::const_iterator it = nodes.begin();

while (it != nodes.end()) {
if (*it) return false;
++it;
}
return true;
}

void BinarySearchTree::PrintWhiteSpaces(int num)
{
for (int i = 0; i<num; ++i)
cout << " ";
}

int BinarySearchTree::max(int a, int b)
{
return a > b ? a : b;
}
#pragma endregion

测试类
#pragma once
#include "stdafx.h"
#include "BinarySearchTree.h"
#include "MultiTreeNodeOperation.h"

void WaitUserPressAKey();

int main()
{
int arrs[] = { 6,2,8,1,4,3};
BinarySearchTree* myTree = new BinarySearchTree();
cout << "insert 6,2,8,1,4,3:" << endl;
for each (int item in arrs)
{
myTree->Insert(item);
}
myTree->ShowTree();

myTree->Insert(5);
cout << "insert 5:" << endl;
myTree->ShowTree();
myTree->Delete(4);
cout << "delete 4:" << endl;
myTree->ShowTree();

运行结果