33,027
社区成员
发帖
与我相关
我的任务
分享哪位高人用C++写过R树的程序，能给我发一份吗？
找了好久也没找到，做实验用，想参考一下源代码，自己还写不出来
有的发我邮箱里wdwgr@163.com
非常感谢！
有的发我邮箱里wdwgr@163.com
非常感谢！
...全文
请发表友善的回复…
发表回复
wdwgr 2009-10-16
- 打赏
- 举报
不是RB树，是另一种数据结构
rtree
rtree
elated 2009-10-16
- 打赏
- 举报
elated 2009-10-16
- 打赏
- 举报
我真是孤陋寡闻了
elated 2009-10-16
- 打赏
- 举报
[Quote=引用 3 楼 wdwgr 的回复:]
楼上的你的代码是红黑树，我想要r树的代码，不知道你那有没有，学习数据库和C++呢研究一下r树代码
哪位能帮一下忙，非常谢谢！
[/Quote]
r树是什么？不是RB树么？
楼上的你的代码是红黑树，我想要r树的代码，不知道你那有没有，学习数据库和C++呢研究一下r树代码
哪位能帮一下忙，非常谢谢！
[/Quote]
r树是什么？不是RB树么？
wdwgr 2009-10-16
- 打赏
- 举报
楼上的你的代码是红黑树，我想要r树的代码，不知道你那有没有，学习数据库和C++呢研究一下r树代码
哪位能帮一下忙，非常谢谢！
哪位能帮一下忙，非常谢谢！
elated 2009-10-16
- 打赏
- 举报
//RedBlackTree.cpp
#include "RedBlackTree.h"
template <typename T>
RedBlackTree<T>::RedBlackTree()
{
root = & nil;
}
template <typename T>
RedBlackTree<T>::~RedBlackTree()
{
clear(root);
}
template <typename T>
typename RedBlackTree<T>::Node<T>& RedBlackTree<T>::maximum ( Node<T> * pNode ) const
{
Node<T> *max = pNode
while (max->right != 0) {
max = max->right;
}
return *max;
}
template <typename T>
typename RedBlackTree<T>::Node<T> & RedBlackTree<T>::minimum( Node<T>* pNode ) const
{
Node<T>* min = pNode;
while (min->left != & nil)
{
min = min->left;
}
return *min;
}
template <typename T>
typename RedBlackTree<T>::Node<T> & RedBlackTree<T>::predecessor( Node<T> * pNode) const
{
if(pNode->left != & nil)
return maxmimum(pTNode->left);
Node<T> * p = pNode->parent;
Node<T> * temp = pNode;
while (p != & nil && pNode == p->left) {
temp = p;
p = temp->parent;
}
return *p;
}
template <typename T>
typename RedBlackTree<T>::Node<T> & RedBlackTree<T>::successor( Node<T>* pNode) const
{
if(pNode->right != & nil){
return minimum(pNode->right);
}
Node<T> * p = pNode->parent;
Node<T> * temp = pNode;
while ( p!=& nil && p->right == temp){
temp = p;
p = pNode->parent;
}
return *p;
}
template <typename T>
typename RedBlackTree<T>::TreeNode * RedBlackTree<T>::search(const T& value) const
{
TreeNode* _pTreeNode = root;
while(_pTreeNode != &nil){
if(value<_pTreeNode->key){
_pTreeNode = _pTreeNode->left;
}
else if(value>_pTreeNode->key){
_pTreeNode=_pTreeNode->right;
}
else
{
return _pTreeNode; //找到,返回
}
}
return _pTreeNode; //未找到,返回&nil;
}
template <typename T>
void RedBlackTree<T>::left_rotate(Node<T> * pNode)
{
Node<T> * _child = pNode->right;
pNode->right = _child->left;
if (_child->left != &nil)
{
_child->left->parent = pNode;
}
_child->parent = pNode->parent;
if (pNode->parent == & nil)
{
root = _child;
}
else if (pNode == pNode->parent->left)
{
pNode->parent->left = _child;
}
else
pNode->parent->right =_child;
_child->left = pNode;
pNode->parent = _child;
}
template <typename T>
void RedBlackTree<T>::right_rotate(Node<T> * pNode)
{
Node<T> * _child = pNode->left;
pNode->left = _child->right;
if (_child->right != &nil)
{
_child->right->parent = pNode;
}
_child->parent = pNode->parent;
if (pNode->parent == & nil)
{
root = _child;
}
else if (pNode == pNode->parent->right)
{
pNode->parent->right = _child ;
}
else
pNode->parent->left = _child;
_child->right = pNode;
pNode->parent = _child;
}
template <typename T>
void RedBlackTree<T>::insert_fixup(Node<T> * pnode)
{
while (pnode->parent->color == RED)
{
if (pnode->parent == pnode->parent->parent->left) //pnoder的父亲是左孩子
//the parent of the node is left child
//the grandparent of the node is not nil, because the parent is RED
{
Node<T>* _uncle = pnode->parent->parent->right ;
//the uncle of the node;
if (_uncle->color == RED ) //pnode的叔叔是红色的
{
pnode->parent->color = BLACK;
_uncle->color = BLACK;
pnode = pnode->parent->parent ;
}
else
{
if ( pnode == pnode->parent->right ) //pnode的叔叔是黑色的且pnode是右儿子
{
pnode = pnode->parent;
left_rotate(pnode);
}
pnode->parent->color = BLACK ; //pnode的叔叔是黑色的且pnode是右儿子
pnode->parent->parent->color = RED ;
right_rotate(pnode->parent->parent);
}
}
else //pnode的父亲是右孩子,和上一种情况左右相反
{
Node<T>* _uncle = pnode->parent->parent->left ;
if (_uncle->color == RED )
{
pnode->parent->color = BLACK;
_uncle->color = BLACK;
pnode = pnode->parent->parent ;
}
else
{
if ( pnode == pnode->parent->left )
{
pnode = pnode->parent;
right_rotate(pnode);
}
pnode->parent->color = BLACK ;
pnode->parent->parent->color = RED ;
left_rotate(pnode->parent->parent);
}
}
if (root->color != BLACK)
root->color = BLACK ;
}
}
template <typename T>
void RedBlackTree<T>::erase_fixup(Node<T> * pnode)
{
while (pnode != root && pnode->color == BLACK )
{
Node<T>* _brother ;
if ( pnode == pnode->parent->left)
{
_brother = pnode->parent->right;
if (_brother == & nil )
//由红黑树的性质得到 pnode == &nil, _brother == &nil
{
pnode = pnode->parent;
continue;
}
if (_brother->color == RED)
//pnode的兄弟是红的
{
_brother->color = BLACK;
pnode->parent->color = RED;
left_rotate(pnode->parent);
_brother = pnode->parent->right;
}
else
{
if(_brother->left->color == BLACK && _brother->right->color == BLACK)
//pnode的兄弟是黑的,且有两个黑的儿子
{
_brother->color = RED;
pnode = pnode->parent;
}
else if (_brother->right->color == BLACK)
//pnode的兄弟是黑的,且它的兄弟的右儿子是黑的,左儿子是红的
{
_brother->left->color = BLACK ;
_brother->color = RED;
right_rotate(_brother);
_brother = _brother->parent->right;
}
//pnode的兄弟是黑的,且它的兄弟的右儿子是红的
_brother->color = pnode->parent->color;
pnode->parent->color = BLACK;
_brother->right->color = BLACK;
left_rotate(pnode->parent);
pnode = root;
}
}
else
{
_brother = pnode->parent->left;//pnode是右儿子,和上述过程相同,左右相反
if (_brother == & nil)
//由红黑树的性质得到 pnode == &nil, _brother == &nil
{
pnode = pnode->parent;
continue;
}
if (_brother->color == RED)
{
_brother->color = BLACK;
pnode->parent->color = RED;
right_rotate(pnode->parent);
_brother = pnode->parent->left;
}
else
{
if(_brother->right->color == BLACK && _brother->left->color == BLACK)
{
_brother->color = RED;
pnode = pnode->parent;
}
else if (_brother->left->color == BLACK)
{
_brother->right->color = BLACK ;
_brother->color = RED;
left_rotate(_brother);
_brother = _brother->parent->left;
}
_brother->color = pnode->parent->color;
pnode->parent->color = BLACK;
_brother->left->color = BLACK;
right_rotate(pnode->parent);
pnode = root;
}
}
}
pnode->color = BLACK;
}
template <typename T>
const typename RedBlackTree<T>::Node<T>& RedBlackTree<T>::insert(const T& pT)
{
if (root == & nil)
{
root = new Node<T>(pT);
return *root ;
}
Node<T>* z = new Node<T>(pT);
Node<T>* y = &nil ;
Node<T>* x = root;
while (x != & nil)
{
y = x;
if (z->key < x->key)
{
x = y->left;
}
else
x = y->right;
}
z->parent = y;
if (y == &nil )
{
root = z;
}
else if (z->key < y->key)
{
y->left = z;
}
else
y->right = z;
//z->left = &nil;
z->color = RED;
insert_fixup(z);
return *z;
}
template <typename T>
void RedBlackTree<T>::erase( Node<T> * pnode)
{
Node<T> * _todel; //the node that will be deleted
Node<T> * _child; //the son of the node to be deleted
if (pnode->left == &nil || pnode->right ==& nil)
_todel = pnode;
else
_todel = & successor(pnode);
if (_todel->left != &nil)
_child = _todel->left;
else
_child = _todel->right;
//if ( _child != &nil)
//如果child == &nil ,修改nil.parent = todel->parent;
_child->parent = _todel->parent;
if (_todel->parent == &nil)
root = _child ;
else
{
if (_todel->parent->left == _todel)
_todel->parent->left = _child;
else
_todel->parent->right = _child;
}
if (_todel != pnode)
//copy _todel's satellite data into pnode
{
pnode->key = _todel->key;
pnode->color = _todel->color;
}
if (_todel->color == BLACK)
erase_fixup(_child); //_child maybe = &nil
delete _todel;
nil.parent = 0;
}
template <typename T>
bool RedBlackTree<T>::isnil(TreeNode * pTN)
//判断节点指针是否指向哨兵
{
return pTN == & nil;
}
template <typename T>
template <typename Corp>
void RedBlackTree<T>::post_order( Corp & rhs)
{
//深度优先遍历，后序遍历的非递归实现
//参数rhs是一个Function Object
std::stack<Node<T>*> st;
Node<T>* p = root;
while(true){
while(p != &nil) {
st.push(p);
p = p->left ;
}
p = st.top();
while( p->right == &nil ){
do{
p = st.top();
rhs( p->key);
st.pop();
if (p == root) {
return ;
}
}
while( p== p->parent->right);
p = st.top();
}
p= p->right;
}
}
template <typename T>
void RedBlackTree<T>::in_print()
{
//后序遍历输出
in_print(root);
std::cout<<std::endl ;
}
template <typename T>
inline void RedBlackTree<T>::pre_print()
{
//中序遍历输出
pre_print(root);
std::cout<<std::endl;
}
template <typename T>
void RedBlackTree<T>::in_print(Node<T>* x)
{
if (x!= &nil){
in_print(x->left);
std::cout<<x->key<<" ";
in_print(x->right);
}
}
template <typename T>
void RedBlackTree<T>::pre_print(Node<T> * x)
{
if(x!= &nil){
std::cout<<x->key<<' ';
pre_print(x->left);
pre_print(x->right);
}
}template <typename T>
void RedBlackTree<T>::clear(Node<T>* pNode)
//递归删除每个节点
{
if(pNode != &nil){
clear(pNode->left);
clear(pNode->right);
delete pNode;
}
}
#include <cstdlib>
#include <iostream>
using namespace std;
//仿函数，输出rhs
template <typename T>
class print
{
public:
void operator() (const T &rhs)
{
std::cout<< rhs <<' ';
};
};
elated 2009-10-16
- 打赏
- 举报
//RedBlackTree.h
#include <stack>
template <typename T>
class RedBlackTree
{
public:
enum RedOrBlack
{
RED,
BLACK
};
template <typename N>
struct Node
{
Node(): key(0),left(0),parent(0),color(BLACK){};
explicit Node(const T & rh):key(rh),left(&nil),right(&nil),parent(&nil),color(BLACK){};
Node ( RedOrBlack c):
key(0), left(0), right(0), parent(0), color (c) {};
N key;
Node * left;
Node * right;
Node * parent;
RedOrBlack color ;
};
typedef Node<T> TreeNode;
bool isnil(TreeNode *);
RedBlackTree();
~RedBlackTree();
template <typename Corp>
void post_order( Corp & rhs);
void in_print();
void pre_print();
const Node<T>& insert(const T&);
void erase(Node<T> *);
TreeNode * search(const T & ) const;
private:
RedBlackTree(const RedBlackTree &); //禁止复制
const RedBlackTree & operator = (const RedBlackTree & ); //禁止复制
Node<T> & predecessor(Node<T> *) const;
Node<T> & successor (Node<T> *) const;
Node<T> & minimum(Node<T> *) const;
Node<T> & maximum(Node<T> *) const;
void insert_fixup(Node<T>*);
void erase_fixup(Node<T>*);
void left_rotate(Node<T>* );
void right_rotate(Node<T>* );
void clear(Node<T>*);
void in_print(Node<T>*);
void pre_print(Node<T>*);
private:
Node<T> * root;
static Node<T> nil ; //哨兵节点
};
template <typename T>
typename RedBlackTree<T>::TreeNode RedBlackTree<T>::nil(BLACK);
