二叉查找树的实现——C++

二叉查找树是比较基础的数据结构，可实现排序、二分查找等操作。

但是由于生成方式的局限性(不控制平衡)，当先后插入的关键字有序时，便会形成单支，严重影响效率和性能。（后续要实现的目标当然就是自平衡树了，比如AVL、红黑树）

话不多说，直接贴源码。

头文件(BinarySearchTree.h):

/***********************
* BinarySearchTree.h
**********************/

#pragma once

//节点定义.
typedef struct _BinaryTreeNode
{
int data;
struct _BinaryTreeNode *leftChild, *rightChild;
}BinaryTreeNode;

//二叉查找树类.
class BinarySearchTree
{
private:
BinaryTreeNode* m_pRootNode;	//根节点

public:
BinarySearchTree();
~BinarySearchTree();

//添加节点.
bool AddNode(int data = 0);

//前序遍历.
void PreOrderTraverse();
//中序遍历.
void InOrderTraverse();
//后序遍历.
void PostOrderTraverse();

private:

//插入节点，递归.
void InsertNode(BinaryTreeNode* toNode, BinaryTreeNode* srcNode);

//递归实现前序遍历.
void PreOrder(BinaryTreeNode* node);
//递归实现中序遍历.
void InOrder(BinaryTreeNode* node);
//递归实现后序遍历.
void PostOrder(BinaryTreeNode* node);

//打印节点.
void PrintNode(BinaryTreeNode* node);
//创建新节点.
BinaryTreeNode* CreateNewNode(int data);

//删除所有节点,在析构函数中调用.
void DeleteAllNodes();
//递归删除节点.
void DeleteNode(BinaryTreeNode* node);
};

实现文件(BinarySearchTree.cpp):

/**
* BinarySearchTree.cpp
*/

#include "BinarySearchTree.h"
#include <stdio.h>

BinarySearchTree::BinarySearchTree()
:m_pRootNode(NULL)
{
}

BinarySearchTree::~BinarySearchTree()
{
this->DeleteAllNodes();
}

bool BinarySearchTree::AddNode(int data/* = 0*/)
{
BinaryTreeNode* newNode = this->CreateNewNode(data);
if(!newNode)
return false;

if(!m_pRootNode)
{
m_pRootNode = newNode;
return true;
}

this->InsertNode(m_pRootNode, newNode);
return true;
}
void BinarySearchTree::InsertNode(BinaryTreeNode* toNode, BinaryTreeNode* srcNode)
{
if(!toNode || !srcNode)
return;

if(srcNode->data <= toNode->data)
{
if(!toNode->leftChild)
{
toNode->leftChild = srcNode;
}
else
{
this->InsertNode(toNode->leftChild, srcNode);
}
}
else
{
if(!toNode->rightChild)
{
toNode->rightChild = srcNode;
}
else
{
this->InsertNode(toNode->rightChild, srcNode);
}
}
}

void BinarySearchTree::PreOrderTraverse()
{
this->PreOrder(m_pRootNode);
}
void BinarySearchTree::PreOrder(BinaryTreeNode* node)
{
if(!node)
{
return;
}

this->PreOrder(node->leftChild);
this->PrintNode(node);
this->PreOrder(node->rightChild);
}

void BinarySearchTree::InOrderTraverse()
{
this->InOrder(m_pRootNode);
}
void BinarySearchTree::InOrder(BinaryTreeNode* node)
{
if(!node)
return;

this->PrintNode(node);
this->InOrder(node->leftChild);
this->InOrder(node->rightChild);
}

void BinarySearchTree::PostOrderTraverse()
{
this->PostOrder(m_pRootNode);
}
void BinarySearchTree::PostOrder(BinaryTreeNode* node)
{
if(!node)
return;

this->PostOrder(node->rightChild);
this->PrintNode(node);
this->PostOrder(node->leftChild);
}

BinaryTreeNode* BinarySearchTree::CreateNewNode(int data/* = 0*/)
{
BinaryTreeNode* newNode = new BinaryTreeNode();

if(newNode)
newNode->data = data;

return newNode;
}

void BinarySearchTree::PrintNode(BinaryTreeNode* node)
{
if(!node)
return;

printf("%d ", node->data);
}

void BinarySearchTree::DeleteAllNodes()
{
this->DeleteNode(m_pRootNode);
}
void BinarySearchTree::DeleteNode(BinaryTreeNode* node)
{
if(!node)
return;

//自底向上.
this->DeleteNode(node->leftChild);
this->DeleteNode(node->rightChild);
delete node;
}

测试文件(TestBST.cpp)

/**
* TestBST.cpp
*/
#include "BinarySearchTree.h"

#include <iostream>
#include <time.h>

using namespace std;

bool testBST(int nodeNum)
{
BinarySearchTree* pBST = new BinarySearchTree();

//以当前时间为随机种子.
srand((unsigned int)time(0));

//添加指定个数的元素.
cout<<"Insert: "<<endl;
int tmpData;
for(int i =0; i<nodeNum; ++i)
{
tmpData = rand();
cout<<tmpData<<' ';

if(!pBST->AddNode(tmpData))
{
return false;
}
}

//遍历.
cout<<endl<<endl<<"PreOrder: "<<endl;
pBST->PreOrderTraverse();
cout<<endl<<endl<<"InOrder:"<<endl;
pBST->InOrderTraverse();
cout<<endl<<endl<<"PostOrder:"<<endl;
pBST->PostOrderTraverse();

//清理.
delete pBST;
return true;
}

int main()
{
if(!testBST(10))
{
//cout<<endl<<"测试失败."<<endl;
}

return 0;
}

运行结果：



=============================End===================================