lasd/librerie/exercise5/binarytree/binarytree.hpp

251 lines
9.8 KiB
C++
Executable File

#ifndef BINARYTREE_HPP
#define BINARYTREE_HPP
#include "../container/container.hpp"
#include "../iterator/iterator.hpp"
#include "../queue/queue.hpp"
#include "../queue/vec/queuevec.hpp"
#include "../queue/lst/queuelst.hpp"
#include "../stack/stack.hpp"
#include "../stack/lst/stacklst.hpp"
#include "../stack/vec/stackvec.hpp"
namespace lasd {
template <typename Data>
class BinaryTree : virtual public InOrderMappableContainer<Data>,
virtual public BreadthMappableContainer<Data>,
virtual public InOrderFoldableContainer<Data>,
virtual public BreadthFoldableContainer<Data>{ // Must extend InOrder/BreadthMappableContainer<Data> and InOrder/BreadthFoldableContainer<Data>
public:
struct Node {
private:
protected:
Data data;
// Comparison operators
bool operator==(const Node&) const noexcept; // Comparison of abstract types is possible, but should not be visible.
bool operator!=(const Node&) const noexcept; // Comparison of abstract types is possible, but should not be visible.
bool EqualNodes(const Node&, const Node&) const;
public:
friend class BinaryTree<Data>;
// Destructor
virtual ~Node() = default;
// Copy assignment
Node& operator=(const Node&) = delete; // Copy assignment of abstract types should not be possible.
// Move assignment
Node& operator=(Node&&) noexcept = delete; // Move assignment of abstract types should not be possible.
// Specific member functions
Data& Element(); // Mutable access to the element (concrete function should not throw exceptions)
const Data& Element() const; // Immutable access to the element (concrete function should not throw exceptions)
virtual bool IsLeaf() const noexcept = 0; // (concrete function should not throw exceptions)
virtual bool HasLeftChild() const noexcept = 0; // (concrete function should not throw exceptions)
virtual bool HasRightChild() const noexcept = 0; // (concrete function should not throw exceptions)
virtual Node& LeftChild() const = 0; // (concrete function must throw std::out_of_range when not existent)
virtual Node& RightChild() const = 0; // (concrete function must throw std::out_of_range when not existent)
};
virtual ~BinaryTree() = default;
BinaryTree& operator=(const BinaryTree&) = delete; // Copy assignment of abstract types should not be possible.
BinaryTree& operator=(BinaryTree&&) noexcept = delete; // Move assignment of abstract types should not be possible.
bool operator==(const BinaryTree&) const noexcept; // Comparison of abstract binary tree is possible.
bool operator!=(const BinaryTree&) const noexcept; // Comparison of abstract binary tree is possible.
virtual Node& Root() const = 0; // (concrete function must throw std::length_error when empty)
/* ----- Map and fold functions ----- */
virtual void MapPreOrder(const typename MappableContainer<Data>::MapFunctor, void*) override; // Override MappableContainer member
virtual void MapPostOrder(const typename MappableContainer<Data>::MapFunctor, void*) override; // Override MappableContainer member
virtual void MapInOrder(const typename MappableContainer<Data>::MapFunctor, void*) override; // Override InOrderMappableContainer member
virtual void MapBreadth(const typename MappableContainer<Data>::MapFunctor, void*) override; // Override BreadthMappableContainer member
virtual void FoldPreOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*) const override; // Override FoldableContainer member
virtual void FoldPostOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*) const override; // Override FoldableContainer member
virtual void FoldInOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*) const override; // Override InOrderFoldableContainer member
virtual void FoldBreadth(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*) const override; // Override BreadthFoldableContainer member
protected:
using BreadthMappableContainer<Data>::size;
/* ----- Auxiliary map and fold functions ----- */
void MapPreOrder(const typename MappableContainer<Data>::MapFunctor, void*, Node*); // Accessory function executing from one node of the tree
void MapPostOrder(const typename MappableContainer<Data>::MapFunctor, void*, Node*); // Accessory function executing from one node of the tree
void MapInOrder(const typename MappableContainer<Data>::MapFunctor, void*, Node*); // Accessory function executing from one node of the tree
void MapBreadth(const typename MappableContainer<Data>::MapFunctor, void*, Node*); // Accessory function executing from one node of the tree
void FoldPreOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*, const Node*) const; // Accessory function executing from one node of the tree
void FoldPostOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*, const Node*) const; // Accessory function executing from one node of the tree
void FoldInOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*, const Node*) const; // Accessory function executing from one node of the tree
void FoldBreadth(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*, Node*) const; // Accessory function executing from one node of the tree
};
template <typename Data>
class BTPreOrderIterator : virtual public ForwardIterator<Data> { // Must extend ForwardIterator<Data>
protected:
struct BinaryTree<Data>::Node* curr = nullptr;
StackLst<struct BinaryTree<Data>::Node*> stack;
public:
virtual ~BTPreOrderIterator();
BTPreOrderIterator(const BinaryTree<Data>&); // An iterator over a given binary tree
BTPreOrderIterator(const BTPreOrderIterator&);
BTPreOrderIterator(BTPreOrderIterator&&) noexcept;
BTPreOrderIterator& operator=(const BTPreOrderIterator&);
BTPreOrderIterator& operator=(BTPreOrderIterator&&) noexcept;
bool operator==(const BTPreOrderIterator&) const noexcept;
bool operator!=(const BTPreOrderIterator&) const noexcept;
// Specific member functions (inherited from Iterator)
Data& operator*() const; // (throw std::out_of_range when terminated)
bool Terminated() const noexcept; // (should not throw exceptions)
// Specific member functions (inherited from ForwardIterator)
void operator++(); // (throw std::out_of_range when terminated)
};
/* ************************************************************************** */
template <typename Data>
class BTPostOrderIterator : virtual public ForwardIterator<Data> { // Must extend ForwardIterator<Data>
protected:
struct BinaryTree<Data>::Node* curr = nullptr;
StackLst<struct BinaryTree<Data>::Node*> stack;
struct BinaryTree<Data>::Node* DeepestLeftLeaf(struct BinaryTree<Data>::Node*);
public:
BTPostOrderIterator(const BinaryTree<Data>&); // An iterator over a given binary tree
BTPostOrderIterator(const BTPostOrderIterator&);
BTPostOrderIterator(BTPostOrderIterator&&) noexcept;
virtual ~BTPostOrderIterator();
BTPostOrderIterator& operator=(const BTPostOrderIterator&);
BTPostOrderIterator& operator=(BTPostOrderIterator&&) noexcept;
bool operator==(const BTPostOrderIterator&) const noexcept;
bool operator!=(const BTPostOrderIterator&) const noexcept;
// Specific member functions (inherited from Iterator)
Data& operator*() const; // (throw std::out_of_range when terminated)
bool Terminated() const noexcept; // (should not throw exceptions)
// Specific member functions (inherited from ForwardIterator)
void operator++(); // (throw std::out_of_range when terminated)
};
/* ************************************************************************** */
template <typename Data>
class BTInOrderIterator : virtual public ForwardIterator<Data> { // Must extend ForwardIterator<Data>
protected:
struct BinaryTree<Data>::Node* curr = nullptr;
StackLst<struct BinaryTree<Data>::Node*> stack;
struct BinaryTree<Data>::Node* MostLeftNode(struct BinaryTree<Data>::Node&);
public:
BTInOrderIterator(const BinaryTree<Data>&); // An iterator over a given binary tree
BTInOrderIterator(const BTInOrderIterator&);
BTInOrderIterator(BTInOrderIterator&&) noexcept;
virtual ~BTInOrderIterator();
BTInOrderIterator& operator=(const BTInOrderIterator&);
BTInOrderIterator& operator=(BTInOrderIterator&&) noexcept;
bool operator==(const BTInOrderIterator&) const noexcept;
bool operator!=(const BTInOrderIterator&) const noexcept;
// Specific member functions (inherited from Iterator)
Data& operator*() const; // (throw std::out_of_range when terminated)
bool Terminated() const noexcept; // (should not throw exceptions)
// Specific member functions (inherited from ForwardIterator)
void operator++(); // (throw std::out_of_range when terminated)
};
template <typename Data>
class BTBreadthIterator : virtual public ForwardIterator<Data>{ // Must extend ForwardIterator<Data>
protected:
struct BinaryTree<Data>::Node* curr = nullptr;
QueueVec<struct BinaryTree<Data>::Node*> queue;
public:
BTBreadthIterator(const BinaryTree<Data>&); // An iterator over a given binary tree
BTBreadthIterator(const BTBreadthIterator&);
BTBreadthIterator(BTBreadthIterator&&) noexcept;
virtual ~BTBreadthIterator();
BTBreadthIterator& operator=(const BTBreadthIterator&);
BTBreadthIterator& operator=(BTBreadthIterator&&) noexcept;
bool operator==(const BTBreadthIterator&) const noexcept;
bool operator!=(const BTBreadthIterator&) const noexcept;
// Specific member functions (inherited from Iterator)
Data& operator*() const; // (throw std::out_of_range when terminated)
bool Terminated() const noexcept; // (should not throw exceptions)
// Specific member functions (inherited from ForwardIterator)
void operator++(); // (throw std::out_of_range when terminated)
};
}
#include "binarytree.cpp"
#endif