Library 4

This commit is contained in:
Alessandro Ferro 2021-05-12 12:02:04 +02:00
parent 5aaddb0051
commit 2b7c59412c
1 changed files with 183 additions and 6 deletions

View File

@ -48,14 +48,14 @@ bool BST<Data>::operator==(const BST<Data>& bst) const noexcept{
template <typename Data>
bool BST<Data>::operator!=(const BST<Data>& bst) const noexcept{
return !(*this = bst)
return !(*this == bst);
}
template <typename Data>
void BST<Data>::Insert(const Data& data) noexcept{
NodeLnk*& pointer = FindPointerTo(root, data);
if(pointer == nullptr){
pointer = CreateNode(data);
pointer = BinaryTreeLnk<Data>::CreateNode(data);
size++;
}
}
@ -94,7 +94,7 @@ template <typename Data>
void BST<Data>::RemoveMin(){
if(root == nullptr) throw std::length_error("Empty tree!");
return DetachMin(root);
delete DetachMin(root);
}
@ -116,12 +116,12 @@ template <typename Data>
void BST<Data>::RemoveMax(){
if(root == nullptr) throw std::length_error("Empty tree!");
return DetachMax(root);
delete DetachMax(root);
}
template <typename Data>
const Data& BST<Data>::Predecessor(const Data& data) const{
NodeLnk* const* ptr = FindPointerToPredecessor(root, data)
NodeLnk* const* ptr = FindPointerToPredecessor(root, data);
if(ptr!=nullptr){
return (*(*ptr)).Element();
}else{
@ -151,7 +151,7 @@ void BST<Data>::RemovePredecessor(const Data& data){
template <typename Data>
const Data& BST<Data>::Successor(const Data& data) const{
NodeLnk* const* ptr = FindPointerToSuccessor(root, data)
NodeLnk* const* ptr = FindPointerToSuccessor(root, data);
if(ptr!=nullptr){
return (*(*ptr)).Element();
}else{
@ -179,4 +179,181 @@ void BST<Data>::RemoveSuccessor(const Data& data){
}
}
template <typename Data>
bool BST<Data>::Exists(const Data& data) const noexcept{
return (FindPointerTo(root, data) != nullptr);
}
template <typename Data>
Data BST<Data>::DataNDelete(NodeLnk* ptr){
Data data = ptr->Element();
delete ptr;
return data;
}
template <typename Data>
typename BST<Data>::NodeLnk* BST<Data>::Detach(NodeLnk*& ptrref) noexcept{
if(ptrref == nullptr) return nullptr;
if(ptrref->left == nullptr){
return SkipOnRight(ptrref);
}
else if(ptrref->right == nullptr){
return SkipOnLeft(ptrref);
}
else{
NodeLnk* maxNode = DetachMax(ptrref->left);
std::swap(ptrref->data , maxNode->data);
return maxNode;
}
}
template <typename Data>
typename BST<Data>::NodeLnk* BST<Data>::DetachMin(NodeLnk*& ptrref) noexcept{
return SkipOnRight(FindPointerToMin(ptrref));
}
template <typename Data>
typename BST<Data>::NodeLnk* BST<Data>::DetachMax(NodeLnk*& ptrref) noexcept{
return SkipOnLeft(FindPointerToMax(ptrref));
}
template <typename Data>
typename BST<Data>::NodeLnk* BST<Data>::SkipOnLeft(NodeLnk*& ptrref) noexcept{
NodeLnk* left = nullptr;
if(ptrref != nullptr){
std::swap(left, ptrref->left);
std::swap(left, ptrref);
--size;
}
return left;
}
template <typename Data>
typename BST<Data>::NodeLnk* BST<Data>::SkipOnRight(NodeLnk*& ptrref) noexcept{
NodeLnk* right = nullptr;
if(ptrref != nullptr){
std::swap(right, ptrref->right);
std::swap(right, ptrref);
--size;
}
return right;
}
template <typename Data>
typename BST<Data>::NodeLnk* const& BST<Data>::FindPointerToMin(NodeLnk* const& node) const noexcept{
NodeLnk* const* ptr = &node;
NodeLnk* curr = node;
if(curr!=nullptr){
while(curr->left != nullptr){
ptr = &curr->left;
curr = curr->left;
}
}
return *ptr;
}
template <typename Data>
typename BST<Data>::NodeLnk*& BST<Data>::FindPointerToMin(NodeLnk*& node) noexcept{
return const_cast<NodeLnk*&>(static_cast<const BST<Data> *>(this)->FindPointerToMin(node));
}
template <typename Data>
typename BST<Data>::NodeLnk* const& BST<Data>::FindPointerToMax(NodeLnk* const& node) const noexcept{
NodeLnk* const* ptr = &node;
NodeLnk* curr = node;
if(curr!=nullptr){
while(curr->right != nullptr){
ptr = &curr->right;
curr = curr->right;
}
}
return *ptr;
}
template <typename Data>
typename BST<Data>::NodeLnk*& BST<Data>::FindPointerToMax(NodeLnk*& node) noexcept{
return const_cast<NodeLnk*&>(static_cast<const BST<Data> *>(this)->FindPointerToMax(node));
}
/* ---- END ----- */
template <typename Data>
typename BST<Data>::NodeLnk* const& BST<Data>::FindPointerTo(NodeLnk* const& node) const noexcept{
NodeLnk* const* ptr = &node;
NodeLnk* curr = node;
if(curr!=nullptr){
while(curr!=nullptr || curr->Element() != node->Element()){
if(curr->Element() < node->Element()){
ptr = &curr->right;
curr = curr->right;
}else if(curr->Element() > node->Element()){
ptr = &curr->left;
curr = curr->left;
}
}
}
if(curr->Element() == node->Element()) return *ptr;
else return nullptr;
}
template <typename Data>
typename BST<Data>::NodeLnk*& BST<Data>::FindPointerTo(NodeLnk*& node) noexcept{
return const_cast<NodeLnk*&>(static_cast<const BST<Data> *>(this)->FindPointerTo(node));
}
template <typename Data>
typename BST<Data>::NodeLnk* const& BST<Data>::FindPointerToPredecessor(NodeLnk* const& node) const noexcept{
if(node == nullptr) return nullptr;
NodeLnk* const* ptr = &node;
NodeLnk* curr = node;
NodeLnk* lastRight;
while(curr!=nullptr || node->Element() != curr->Element()){
if(node->Element() == curr->Element()){
ptr = FindPointerToMax(curr->left);
}else if(node->Element() < curr->Element()){
ptr = &curr->left;
curr = curr->left;
}else{
ptr = &curr->right;
curr = curr->right;
lastRight = ptr;
}
}
if(node->Element() == curr->Element()) return *ptr;
else return lastRight;
}
template <typename Data>
typename BST<Data>::NodeLnk*& BST<Data>::FindPointerToPredecessor(NodeLnk*& node) noexcept{
return const_cast<NodeLnk*&>(static_cast<const BST<Data> *>(this)->FindPointerToPredecessor(node));
}
template <typename Data>
typename BST<Data>::NodeLnk* const& BST<Data>::FindPointerToSuccessor(NodeLnk* const& node) const noexcept{
if(node == nullptr) return nullptr;
NodeLnk* const* ptr = &node;
NodeLnk* curr = node;
NodeLnk* lastLeft;
while(curr!=nullptr || node->Element() != curr->Element()){
if(node->Element() == curr->Element()){
ptr = FindPointerToMin(curr->left);
}else if(node->Element() < curr->Element()){
ptr = &curr->left;
curr = curr->left;
lastLeft = ptr;
}else{
ptr = &curr->right;
curr = curr->right;
}
}
if(node->Element() == curr->Element()) return *ptr;
else return lastLeft;
}
template <typename Data>
typename BST<Data>::NodeLnk*& BST<Data>::FindPointerToSuccessor(NodeLnk*& node) noexcept{
return const_cast<NodeLnk*&>(static_cast<const BST<Data> *>(this)->FindPointerToSuccessor(node));
}
}