搜索二叉树含迭代器
vs2013下编写的项目工程见
我的
github: https://github.com/excelentone/DataStruct
#include<iostream>
#include<cassert>
using namespace std;
template<class K, class V>
struct BSTNode
{
BSTNode(const K& key=0, const V& value=0)
: _pLeft(NULL)
, _pRight(NULL)
, _pParent(NULL)
, _key(key)
, _value(value)
{}
BSTNode<K, V>* _pParent;
BSTNode<K, V>* _pLeft;
BSTNode<K, V>* _pRight;
K _key;
V _value;
};
//
template<typename K, typename V>
class BinaryIterator
{
private:
typedef BSTNode<K, V> Node;
typedef BinaryIterator<K, V/*, K&, V&*/> Iterator;
public:
BinaryIterator(Node *pNode = nullptr) :_pNode(pNode)
{}
Iterator &operator++()
{
_Increase(_pNode);
return *this;
}
Iterator &operator--()
{
_Decrease(_pNode);
return *this;
}
Iterator operator++(int)
{
Iterator temp(*this);
++(*this);
return temp;
}
Iterator operator--(int)
{
Iterator temp(*this);
--(*this);
return temp;
}
bool operator==(Iterator &it)
{
return _pNode == it._pNode;
}
bool operator!=(Iterator &it)
{
return !(*this == it);
}
private:
Node *FindMax(Node *pCur)
{
assert(pCur);
while (pCur->_pRight)
pCur = pCur->_pRight;
return pCur;
}
Node *FindMin(Node *pCur)
{
assert(pCur);
while (pCur->_pLeft)
pCur = pCur->_pLeft;
return pCur;
}
void _Increase(Node *pNode)
{
if (pNode->_pRight)
{
pNode = FindMin(pNode->_pRight);
}
else
{
Node *pParent = pNode->_pParent;
while (pParent->_pRight == pNode)
{
pNode = pParent;
pParent = pNode->_pParent;
}
if (pParent->_pRight != pNode)
pNode = pParent;
}
_pNode = pNode;
}
void _Decrease(Node *pNode)
{
if (pNode->_pLeft)
{
pNode = FindMax(pNode->_pLeft);
}
else
{
Node *pParent = pNode->_pParent;
while (pParent->_pLeft == pNode)
{
pNode = pParent;
pParent = pNode->_pParent;
}
pNode = pParent;
}
_pNode = pNode;
}
public:
Node *_pNode;
};
template<class K, class V>
class BinarySearchTree
{
typedef BSTNode<K, V> Node;
typedef BinarySearchTree<K, V> Self;
public:
BinarySearchTree()
: _pRoot(NULL), _pHead(new Node())
{}
BinarySearchTree(const Self& bst)
{
_pRoot=_Init(bst._pRoot);
}
Self& operator=(const Self& bst)
{
if (this != &bst)
{
if (_pRoot)
{
_DestroyTree(_pRoot);
}
_pRoot=_Init(bst._pRoot);
}
return *this;
}
~BinarySearchTree()
{
_DestroyTree(_pRoot);
}
// 查找递归和非递归
Node * Find_Nor(const K& key)
{
return _Find_Nor(_pRoot,key);
}
Node * Find(const K& key)
{
return _Find(_pRoot, key);
}
// 插入递归和非递归
bool Insert_Nor(const K& key, const V& value)
{
if (NULL == _pRoot)
{
_pRoot = new Node(key, value);
return true;
}
return _Insert_Nor(_pRoot, key,value);
}
bool Insert(const K& key, const V& value)
{
bool flag=_Insert(_pRoot,NULL,key, value);
_pHead->_pParent = _pRoot;
_pRoot->_pParent = _pHead;
_pHead->_pLeft = FindMin(_pRoot);
_pHead->_pRight = FindMax(_pRoot);
return flag;
}
// 删除递归和非递归
bool Remove_Nor(const K& key)
{
return _Remove_Nor(_pRoot,key/*,false*/);
}
bool Remove(const K& key)
{
bool flag= _Remove(_pRoot, key);
_pHead->_pParent = _pRoot;
_pRoot->_pParent = _pHead;
_pHead->_pLeft = FindMin(_pRoot);
_pHead->_pRight = FindMax(_pRoot);
return flag;
}
void InOrder()
{
cout << "InOrder:";
_InOrder(_pRoot);
cout << endl;
}
Node * ToList()
{
Node *pre = NULL;
_ToList(_pRoot, pre);
return FindMin(_pRoot);
}
BinaryIterator<K, V> end()
{
return BinaryIterator<K, V> (_pHead);
}
BinaryIterator<K, V> begin()
{
return BinaryIterator<K, V>(FindMin(_pRoot));
}
private:
Node * _Find_Nor(Node *pRoot, const K &key)
{
Node *pCur = pRoot;
while (pCur)
{
if (key < pCur->_key)
{
pCur = pCur->_pLeft;
}
else if (key>pCur->_key)
{
pCur = pCur->_pRight;
}
else
{
return pRoot;
}
}
return NULL;
}
Node *FindMin(Node *pCur)
{
assert(pCur);
while (pCur->_pLeft)
pCur = pCur->_pLeft;
return pCur;
}
Node *FindMax(Node *pCur)
{
assert(pCur);
while (pCur->_pRight)
pCur = pCur->_pRight;
return pCur;
}
Node* _Find(Node* pRoot, const K& key)
{
if (NULL == pRoot)
{
return false;
}
if (key < pRoot->_key)
{
_Find(pRoot->_pLeft, key);
}
else if (key>pRoot->_key)
{
_Find(pRoot->_pRight, key);
}
else
{
return pRoot;
}
}
bool _Insert_Nor(Node* pRoot, const K &key, const V &value)
{
while (pRoot)
{
if (key < pRoot->_key)
{
if (NULL == pRoot->_pLeft)
{
pRoot->_pLeft = new Node(key, value);
return true;
}
else
pRoot = pRoot->_pLeft;
}
else if (key>pRoot->_key)
{
if (NULL == pRoot->_pRight)
{
pRoot->_pRight = new Node(key, value);
return true;
}
else
pRoot = pRoot->_pRight;
}
else
{
return false;
}
}
return true;
}
bool _Insert(Node* &pRoot, Node *pParent,const K& key, const V& value)
{
if (NULL == pRoot)
{
pRoot = new Node(key, value);
pRoot->_pParent = pParent;
return true;
}
if (key < pRoot->_key)
{
pParent = pRoot;
_Insert(pRoot->_pLeft,pParent, key, value);
}
else if (key>pRoot->_key)
{
pParent = pRoot;
_Insert(pRoot->_pRight, pParent, key, value);
}
else
{
return false;
}
return true;
}
bool _Remove(Node*& pRoot, const K& key)
{
if (NULL == pRoot)
{
return false;
}
if (pRoot->_key > key)
{
_Remove(pRoot->_pLeft, key);
}
else if (pRoot->_key < key)
{
_Remove(pRoot->_pRight, key);
}
else
{
if (NULL != pRoot->_pLeft&&NULL != pRoot->_pRight)
{
Node *pDel = pRoot;
pRoot->_key = FindMin(pRoot->_pRight)->_key;
_Remove(pRoot->_pRight, pRoot->_key);
}
else
{
Node *pDel = pRoot;
if (pRoot->_pLeft != NULL)
{
pRoot = pRoot->_pLeft;
}
else
{
pRoot = pRoot->_pRight;
}
delete pDel;
}
}
return false;
}
bool _Remove_Nor(Node *&pRoot, const K &key/*,bool flag*/)
{
Node *pCur = pRoot;
Node *pParent = pCur;
/*if (flag == true)
{
pCur = pCur->_pRight;
}*/
while (pCur)
{
if (key < pCur->_key)
{
pParent = pCur;
pCur = pCur->_pLeft;
}
else if (key>pCur->_key)
{
pParent = pCur;
pCur = pCur->_pRight;
}
else
{
if (pCur->_pLeft&&NULL==pCur->_pRight)
{
if (pCur = pParent->_pLeft)
{
Node *pTemp = pCur;
pParent->_pLeft = pCur->_pLeft;
delete pTemp;
}
else if (pCur = pParent->_pRight)
{
Node *pTemp = pCur;
pParent->_pRight = pCur->_pLeft;
delete pTemp;
}
return true;
}
else if (pCur->_pLeft&&pCur->_pRight)
{
Node *pTempPre = pCur;
Node *pTemp = FindMin(pCur->_pRight);
pCur->_key = pTemp->_key;
_Remove_Nor(pCur->_pRight, pCur->_key);
return true;
}
else
{
if (pCur ==pParent->_pLeft)
{
Node *pTemp = pCur;
pParent->_pLeft = pCur->_pRight;
delete pTemp;
}
else if (pCur == pParent->_pRight)
{
Node *pTemp = pCur;
pParent->_pRight = pCur->_pRight;
delete pTemp;
}
return true;
}
}
}
return false;
}
void _InOrder(Node* pRoot)
{
if (pRoot)
{
_InOrder(pRoot->_pLeft);
cout << pRoot->_key << " ";
_InOrder(pRoot->_pRight);
}
}
Node *_Init(Node *pRoot)
{
if (NULL != pRoot)
{
Node *pNewRoot = new Node(pRoot->_key, pRoot->_value);
pNewRoot->_pLeft = _Init(pRoot->_pLeft);
pNewRoot->_pRight = _Init(pRoot->_pRight);
return pNewRoot;
}
return NULL;
}
void _DestroyTree(Node *pRoot)
{
if (pRoot)
{
_DestroyTree(pRoot->_pLeft);
_DestroyTree(pRoot->_pRight);
delete(pRoot);
pRoot = NULL;
}
}
void _ToList(Node *pRoot, Node *&pre)
{
if (NULL==pRoot)
return;
Node *cur = pRoot;
_ToList(pRoot->_pLeft,pre);
if (pre)
{
pre->_pRight = cur;
}
cur->_pLeft = pre;
pre = cur;
_ToList(pRoot->_pRight,pre);
}
public:
Node* _pRoot;
Node *_pHead;
};
// 测试非递归的三种情况
void Test1()
{
BinarySearchTree<int, int> bst;
int a[] = { 5, 3,4,1, 7, 8, 2, 6, 0, 9 };
for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
bst.Insert(a[i],a[i]);
}
BinarySearchTree<int, int> bstcpy;
bstcpy = bst;
BSTNode<int, int> *list=bst.ToList();
bstcpy.InOrder();
bst.InOrder();
bst.Remove_Nor(6);
bst.InOrder();
cout << bst.Find(10) << endl;
cout << bst.Find_Nor(5) << endl;
}
// 测试递归的三种情况
void Test2()
{
BinarySearchTree<int, int> bst;
int a[] = { 5, 3,4, 1, 7, 8, 2, /*6,*/ 0, 9 };
for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
bst.Insert(a[i], a[i]);
}
//BinaryIterator<int, int> it(bst._pRoot);
it = ++bst.end();
//BSTNode<int, int> *start = bst.Find(3);
//for (it=start; it != bst.end(); it++)
//{
// cout << it._pNode->_key << " ";
//}
cout << endl;
bst.InOrder();
bst.Remove(5);
bst.InOrder();
cout << bst.Find(10) << endl;
cout << bst.Find_Nor(5) << endl;
}
int main()
{
Test1();
//Test2();
system("pause");
}
