php二叉搜索,C++_二叉搜索树源码分享，复制代码 代码如下:#include <i - phpStudy

#include

using namespace std;

//枚举类，前中后三种遍历方式

enum ORDER_MODE

{

ORDER_MODE_PREV = 0,

ORDER_MODE_MID,

ORDER_MODE_POST

};

//树节点的结构体

template

struct BinaryNode

{

T    element;

BinaryNode  *left;

BinaryNode  *right;

BinaryNode(const T& theElement,

BinaryNode *lt,

BinaryNode *rt):

element(theElement),

left(lt),

right(rt)

{

}

};

template

class BinarySearchTree

{

private:

BinaryNode   *m_root;

public:

BinarySearchTree();

BinarySearchTree(const BinarySearchTree& rhs);

~BinarySearchTree();

const T& findMin() const;

const T& findMax() const;

bool contains(const T& x) const;

void printTree(ORDER_MODE eOrderMode = ORDER_MODE_PREV) const;

void makeEmpty();

void insert(const T& x);

void remove(const T& x);

private:

void insert(const T& x, BinaryNode* &t) ;

void remove(const T& x, BinaryNode* &t) ;

BinaryNode* findMin( BinaryNode* t) const;

BinaryNode* findMax( BinaryNode* t) const;

bool contains(const T& x, const BinaryNode* t) const;

void makeEmpty(BinaryNode* &t);

void printTreeInPrev(BinaryNode* t) const;

void printTreeInMid(BinaryNode* t)const;

void printTreeInPost(BinaryNode* t)const;

};

//构造方法

template

BinarySearchTree::BinarySearchTree()

{

m_root = NULL;

}

//使用另一棵二叉搜索树的构造函数

template

BinarySearchTree:: BinarySearchTree(const BinarySearchTree& rhs)

{

m_root = rhs.m_root;

}

//析构函数，释放内存

template

BinarySearchTree:: ~BinarySearchTree()

{

makeEmpty();

}

// 判断x元素是否存在

template

bool  BinarySearchTree::contains(const T& x) const

{

return contains(x, m_root);

}

//递归调用

template

bool BinarySearchTree::contains(const T& x, const BinaryNode* t) const

{

if (!t)

return false;

else if (x < t->element)

return contains(x, t->left);

else if (x > t->element)

return contains(x, t->right);

else

return true;

}

// 寻找树中的最小值

template

const T& BinarySearchTree::findMin() const

{

return findMin(m_root)->element;

}

//递归搜索树中最小值

template

BinaryNode* BinarySearchTree::findMin( BinaryNode* t) const

{

//二叉树的一个特点就是左子叶的值比根节点小， 右子叶的比根节点的大

if (!t)

return NULL;

if (t->left == NULL)

return t;

else

return findMin(t->left);

}

// 寻找树中最大值

template

const T& BinarySearchTree::findMax() const

{

return findMax(m_root)->element;

}

//递归寻找树中最大值

template

BinaryNode* BinarySearchTree::findMax( BinaryNode* t) const

{

//二叉树的一个特点就是左子叶的值比根节点小， 右子叶的比根节点的大

if (t != NULL)

while (t->right != NULL)

t = t->right;

return t;

}

// 插入元素

template

void BinarySearchTree:: insert(const T& x)

{

insert(x, m_root);

}

//递归插入

template

void BinarySearchTree::insert(const T& x, BinaryNode* &t)

{

if (t == NULL)

t = new BinaryNode(x, NULL, NULL);//注意这个指针参数是引用

else if (x < t->element)

insert(x, t->left);

else if (x > t->element)

insert(x, t->right);

else

;//do nothing

}

//移除元素

template

void BinarySearchTree::remove(const T& x)

{

return remove(x, m_root);

}

//递归移除

template

void BinarySearchTree::remove(const T& x, BinaryNode* &t)

{

if (t == NULL)

return;

if (x < t->element)

remove(x, t->left);

else if (x > t->element)

remove (x, t->right);

else // now ==

{

if (t->left != NULL &&

t->right != NULL)//two child

{

t->element = findMin(t->right)->element;

remove(t->element, t->right);

}

else

{

BinaryNode *oldNode = t;

t = (t->left != NULL) ? t->left : t->right;

delete oldNode;

}

}

}

//清空二叉树

template

void  BinarySearchTree::makeEmpty()

{

makeEmpty(m_root);

}

//递归清空

template

void  BinarySearchTree::makeEmpty(BinaryNode* &t)

{

if (t)

{

makeEmpty(t->left);

makeEmpty(t->right);

delete t;

}

t = NULL;

}

// 打印二叉搜索树

template

void BinarySearchTree::printTree(ORDER_MODE eOrderMode /*= ORDER_MODE_PREV*/) const

{

if (ORDER_MODE_PREV == eOrderMode)

printTreeInPrev(m_root);

else if (ORDER_MODE_MID == eOrderMode)

printTreeInMid(m_root);

else if (ORDER_MODE_POST == eOrderMode)

printTreeInPost(m_root);

else

;//do nothing

}

//前序打印

template

void BinarySearchTree::printTreeInPrev(BinaryNode* t) const

{

if (t)

{

cout << t->element;

printTreeInPrev(t->left);

printTreeInPrev(t->right);

}

}

//中序打印

template

void BinarySearchTree::printTreeInMid(BinaryNode* t) const

{

if (t)

{

printTreeInPrev(t->left);

cout << t->element;

printTreeInPrev(t->right);

}

}

//后序打印

template

void BinarySearchTree::printTreeInPost(BinaryNode* t) const

{

if (t)

{

printTreeInPost(t->left);

printTreeInPost(t->right);

cout << t->element;

}

}

```

测试代码

===

```C++

#include "BinarySearchTree.h"

int main()

{

BinarySearchTree binaryTree;

binaryTree.insert(5);

binaryTree.insert(1);

binaryTree.insert(2);

binaryTree.insert(3);

binaryTree.insert(6);

binaryTree.insert(8);

//测试前中后序打印

cout <

binaryTree.printTree(ORDER_MODE_PREV);

cout <

binaryTree.printTree(ORDER_MODE_MID);

cout <

binaryTree.printTree(ORDER_MODE_POST);

cout <

//测试基本操作

bool b = binaryTree.contains(1);

cout<< "是否存在1："<

int x = binaryTree.findMin();

cout << "最小值为："<< x <

x = binaryTree.findMax();

cout << "最大值为："<< x <

binaryTree.remove(2);

cout << "移除元素2之后"<

//测试前中后序打印

cout <

binaryTree.printTree(ORDER_MODE_PREV);

cout <

binaryTree.printTree(ORDER_MODE_MID);

cout <

binaryTree.printTree(ORDER_MODE_POST);

cout <

return 0;

}