Breaking News: Grepper is joining You.com. Read the official announcement!

binarz search tree

Mero answered on August 26, 2023 Popularity 3/10 Helpfulness 1/10

answer binarz search tree

related binarz search tree

binarz search tree

Comment

//
// Created by merom on 5/10/2023.
//

#ifndef HOMEWORK_NO_SUBMISSION_BSTREE_IMPL_H
#define HOMEWORK_NO_SUBMISSION_BSTREE_IMPL_H
#include "BSTree.h"

template<typename T>
void BST<T>::clear_helper(std::unique_ptr<Node<T>>& node) {
    if (node == nullptr) {
        return;
    }
    delete_tree(node->left);
    delete_tree(node->right);
    node.reset();
}


template<typename T>
T BST<T>::get_min_value(const std::unique_ptr<Node<T>> &node) {
    if (node->left == nullptr) {
        return node->value;
    } else {
        return get_min_value(node->left);
    }
}

template <class T>
void  BST<T>::remove_helper( std::unique_ptr<Node<T>> & node, const T& value ) {
    if (node == nullptr) {
        return;
    }
    if (node->value == value) {
        // case 1: node has no children
        if (node->left == nullptr && node->right == nullptr) {
            node.reset(); // delete the node
        }
            // case 2: node has one child
        else if (node->left == nullptr) {
            node = std::move(node->right); // replace with right child
        }
        else if (node->right == nullptr) {
            node = std::move(node->left); // replace with left child
        }
            // case 3: node has two children
        else {
            // find the smallest node in the right subtree
            std::unique_ptr<Node<T>> temp = std::move(node->right);
            while (temp->left != nullptr) {
                temp = std::move(temp->left);
            }
            // replace the value of the node with the value of the smallest node
            node->value = temp->value;
            // remove the smallest node
            remove_helper(node->right, temp->value);
        }
    }
    else if (value < node->value) {
        remove_helper(node->left, value);
    }
    else {
        remove_helper(node->right, value);
    }
}

template<typename T>
const Node<T> * BST<T>::find_helper(const Node<T> * node, const T &value) const {
    if(node->value == value ) {return node;}
    else if(node->value < value) { find_helper(node->left.get(), value); }
    else  { find_helper(node->right.get(),value) ;}
    return nullptr;
}




template<typename T>
void BST<T>::print_helper(Node<T> * node, char c) {
    if(node){
        if(c == 'i'){
            print_helper(node->left.get());
            std::cout << node->value << " ";
            print_helper(node->right.get());
        }else if(c == 'p'){
            std::cout << node->value << " ";
            print_helper(node->left.get());
            print_helper(node->right.get());
        }else{
            print_helper(node->left.get());
            print_helper(node->right.get());
            std::cout << node->value << " ";
        }
    }
}


template<typename T>
void BST<T>::print_inorder() {
    std::cout << "Inorder traversal: ";
    print_helper(_root.get(), 'i');
    std::cout << std::endl;
}

template<typename T>
void BST<T>::print_preorder() {
    std::cout << "preorder traversal: ";
    print_helper(_root.get(), 'p');
    std::cout << std::endl;
}

template<typename T>
void BST<T>::print_postorder() {
    std::cout << "postorder traversal: ";
    print_helper(_root.get(), '\0');
    std::cout << std::endl;
}


template<typename T>
void BST<T>::insert_data(T &&value) {
    if (!_root) {
        _root = std::make_unique<Node<T>>(value);
    } else {
        Node<T>* current = _root.get();
        while (current) {
            if (value < current->value) {
                if (!current->left) {
                    current->left = std::make_unique<Node<T>>(std::move(value));
                    return;
                }
                current = current->left.get();
            } else if (value > current->value) {
                if (!current->right) {
                    current->right = std::make_unique<Node<T>>(std::move(value));
                    return;
                }
                current = current->right.get();
            }else{
                /* value already exists */
                return;
            }
        }
    }
}


template<typename T>
void BST<T>::insert_data(T & value) {
    if (!_root) {
        _root = std::make_unique<Node<T>>(value);
    } else {
        Node<T>* current = _root.get();
        while (current) {
            if (value < current->value) {
                if (!current->left) {
                    current->left = std::make_unique<Node<T>>(value);
                    return;
                }
                current = current->left.get();
            } else if (value > current->value) {
                if (!current->right) {
                    current->right = std::make_unique<Node<T>>(std::move(value));
                    return;
                }
                current = current->right.get();
            }else{
                /* value already exists */
                return;
            }
        }
    }
}


#endif //HOMEWORK_NO_SUBMISSION_BSTREE_IMPL_H

Popularity 3/10 Helpfulness 1/10 Language cpp

Source: Grepper

Tags: c++ search-tree

Link to this answer
Share Copy Link

Contributed on Aug 26 2023

Mero

0 Answers Avg Quality 2/10

Closely Related Answers

binarz search tree

Comment

//
// Created by merom on 5/10/2023.
//

#ifndef HOMEWORK_NO_SUBMISSION_BSTREE_H
#define HOMEWORK_NO_SUBMISSION_BSTREE_H
#include <memory>
#include <iostream>
#include <iostream>
#include <memory>

template<typename T>
struct Node {
    T value;
    std::unique_ptr<Node> left, right;
    explicit Node(T val) : value(val), left(nullptr), right(nullptr) {}
};

template<typename T>
class BST {
public:
    /*ctr's*/
    BST() : _root(nullptr) {}

public:
    /*Printing*/
    void print_inorder();
    void print_preorder();
    void print_postorder();

public:
    /* setter */
    void insert(T && value){
        insert_data(std::move(value));
    }
    void insert(T & value){
        insert_data(value);
    }

public:
    /*Get value */
     T find(const T& value) const {
        auto val = find_helper(_root.get(), value);
        return val->value;
    }

public:
    /*Remove*/
    void remove(const T &data) {
         remove_helper(_root, data) ;
    }

public:
    /*Delete the whole tree*/
    void clear() {
        clear_helper(_root);
    }
public:
    /*get _root */
    const Node<T> * get_root() const { return _root.get(); }


private:
    std::unique_ptr<Node<T>> _root;
private:
    void print_helper(Node<T>*, char c ='i');
    void insert_data(T && val);
    void insert_data(T & val);
    const Node<T> * find_helper(const Node<T> * node,const T& value) const ;
    T get_min_value(const std::unique_ptr<Node<T>>& node);
    void remove_helper(std::unique_ptr<Node<T>> &  , const T & data);
private:
    void clear_helper(std::unique_ptr<Node<T>>& node);

};



#endif //HOMEWORK_NO_SUBMISSION_BSTREE_H
#include "BSTree_impl.h"

Popularity 3/10 Helpfulness 1/10 Language cpp

Source: Grepper

Tags: c++ search-tree

Link to this answer
Share Copy Link

Contributed on Aug 26 2023

Mero

0 Answers Avg Quality 2/10

binarz search tree

Contents

More Related Answers

binarz search tree

Closely Related Answers

binarz search tree

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.