mirror of
https://github.com/genodelabs/genode.git
synced 2024-12-20 22:23:16 +00:00
204 lines
4.3 KiB
C++
204 lines
4.3 KiB
C++
/*
|
|
* \brief AVL tree
|
|
* \author Norman Feske
|
|
* \date 2006-04-12
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2006-2012 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU General Public License version 2.
|
|
*/
|
|
|
|
#ifndef _INCLUDE__UTIL__AVL_TREE_H_
|
|
#define _INCLUDE__UTIL__AVL_TREE_H_
|
|
|
|
#include <util/misc_math.h>
|
|
|
|
namespace Genode {
|
|
|
|
class Avl_node_base
|
|
{
|
|
protected:
|
|
|
|
/**
|
|
* Internal policy interface
|
|
*
|
|
* The implementation of this interface is provided by the AVL tree.
|
|
*/
|
|
struct Policy
|
|
{
|
|
virtual ~Policy() { }
|
|
|
|
/**
|
|
* Compare two nodes
|
|
*
|
|
* \retval false if n2 is lower than n1
|
|
* \retval true if n2 is higher than or equal to n1
|
|
*
|
|
* This function must be provided by the derived class.
|
|
* It determines the order of nodes inside the avl tree.
|
|
*/
|
|
virtual bool higher(Avl_node_base *n1, Avl_node_base *n2) const = 0;
|
|
|
|
/**
|
|
* Node recomputation hook
|
|
*
|
|
* If a node gets rearranged, this function is called.
|
|
* It can be used to update avl-tree-position dependent
|
|
* meta data.
|
|
*/
|
|
virtual void recompute(Avl_node_base *) { }
|
|
};
|
|
|
|
Avl_node_base *_child[2]; /* left and right subtrees */
|
|
Avl_node_base *_parent; /* parent of subtree */
|
|
unsigned char _depth; /* depth of subtree */
|
|
|
|
public:
|
|
|
|
typedef bool Side;
|
|
|
|
enum { LEFT = false, RIGHT = true };
|
|
|
|
private:
|
|
|
|
/**
|
|
* Determine depth of subtree
|
|
*/
|
|
inline int _child_depth(Side i) {
|
|
return _child[i] ? _child[i]->_depth : 0; }
|
|
|
|
/**
|
|
* Update depth of node
|
|
*/
|
|
void _recompute_depth(Policy &policy);
|
|
|
|
/**
|
|
* Determine left-right bias of both subtrees
|
|
*/
|
|
inline Side _bias() {
|
|
return (_child_depth(RIGHT) > _child_depth(LEFT)); }
|
|
|
|
/**
|
|
* Insert subtree into specified side of the node
|
|
*/
|
|
void _adopt(Avl_node_base *node, Side i, Policy &policy);
|
|
|
|
/**
|
|
* Rotate subtree
|
|
*
|
|
* \param side direction of rotate operation
|
|
* \param node subtree to rotate
|
|
*
|
|
* The local node_* variable names describe node locations for
|
|
* the left (default) rotation. For example, node_r_l is the
|
|
* left of the right of node.
|
|
*/
|
|
void _rotate_subtree(Avl_node_base *node, Side side, Policy &policy);
|
|
|
|
/**
|
|
* Rebalance subtree
|
|
*
|
|
* \param node immediate child that needs balancing
|
|
*
|
|
* 'this' is parent of the subtree to rebalance
|
|
*/
|
|
void _rebalance_subtree(Avl_node_base *node, Policy &policy);
|
|
|
|
public:
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
Avl_node_base();
|
|
|
|
/**
|
|
* Insert new node into subtree
|
|
*/
|
|
void insert(Avl_node_base *node, Policy &policy);
|
|
|
|
/**
|
|
* Remove node from tree
|
|
*/
|
|
void remove(Policy &policy);
|
|
};
|
|
|
|
|
|
/**
|
|
* AVL node
|
|
*
|
|
* \param NT type of the class derived from 'Avl_node'
|
|
*
|
|
* Each object to be stored in the avl tree must be derived from
|
|
* 'Avl_node'. The type of the derived class is to be specified as
|
|
* template argument to enable 'Avl_node' to call virtual functions
|
|
* specific for the derived class.
|
|
*/
|
|
template <typename NT>
|
|
class Avl_node : public Avl_node_base
|
|
{
|
|
public:
|
|
|
|
inline NT *child(Side i) const { return static_cast<NT *>(_child[i]); }
|
|
|
|
/**
|
|
* Default policy
|
|
*/
|
|
void recompute() { }
|
|
};
|
|
|
|
|
|
/**
|
|
* Root node of the AVL tree
|
|
*
|
|
* The real nodes are always attached at the left branch of
|
|
* this root node.
|
|
*/
|
|
template <typename NT>
|
|
class Avl_tree : Avl_node<NT>
|
|
{
|
|
private:
|
|
|
|
/**
|
|
* Auto-generated policy class specific for NT
|
|
*/
|
|
class Policy : public Avl_node_base::Policy
|
|
{
|
|
bool higher(Avl_node_base *n1, Avl_node_base *n2) const
|
|
{
|
|
return static_cast<NT *>(n1)->higher(static_cast<NT *>(n2));
|
|
}
|
|
|
|
void recompute(Avl_node_base *node)
|
|
{
|
|
static_cast<NT *>(node)->recompute();
|
|
}
|
|
|
|
} _policy;
|
|
|
|
public:
|
|
|
|
/**
|
|
* Insert node into AVL tree
|
|
*/
|
|
void insert(Avl_node<NT> *node) { Avl_node_base::insert(node, _policy); }
|
|
|
|
/**
|
|
* Remove node from AVL tree
|
|
*/
|
|
void remove(Avl_node<NT> *node) { node->remove(_policy); }
|
|
|
|
/**
|
|
* Request first node of the tree
|
|
*
|
|
* \return first node
|
|
* \retval NULL if tree is empty
|
|
*/
|
|
inline NT *first() const { return this->child(Avl_node<NT>::LEFT); }
|
|
};
|
|
}
|
|
|
|
#endif /* _INCLUDE__UTIL__AVL_TREE_H_ */
|