具有3个值的C ++二叉树

Question

So I am attempting to create a binary search tree that stores an ID (T value) an age (int age) and a name (string) per each "bubble" located within the tree and is sorted by the ID.

For some reason, I cannot get my code to correctly store all 3 values as 1 structure per node. Is there something I am doing wrong?

Here's my code.

#ifndef _TREE_GUARD 
#define _TREE_GUARD 1

#include <iostream>
#include <math.h>
using namespace std;

template <class T>
struct Node {
    T value;
    int age;
    string name;
    Node *left;
    Node *right;

    Node(T val) {
        this->value = val;
    }

    Node(T val, int age, string name, Node<T> left, Node<T> right) {
        this->value = val;
        this->age = age;
        this->name = name;

        this->left = left;
        this->right = right;
    }
};

template <class T>
class BST {

private:
    Node<T> *root;

    void addHelper(Node<T> *root, T val) {
        if (root->value > val) {
            if (!root->left) {
                root->left = new Node<T>(val);
            }
            else {
                addHelper(root->left, val);
            }
        }
        else {
            if (!root->right) {
                root->right = new Node<T>(val);
            }
            else {
                addHelper(root->right, val);
            }
        }
    }

    void printHelper(Node<T> *root) {
        if (!root) return;
        printHelper(root->left);
        cout << root->value << ' ';
        cout << root->age << ' '; // ADDED
        cout << root->name << ' '; //ADDED
        printHelper(root->right);
    }

    int nodesCountHelper(Node<T> *root) {
        if (!root) return 0;
        else return 1 + nodesCountHelper(root->left) + nodesCountHelper(root->right);
    }

    int heightHelper(Node<T> *root) {
        if (!root) return 0;
        else return 1 + max(heightHelper(root->left), heightHelper(root->right));
    }

    void printMaxPathHelper(Node<T> *root) {
        if (!root) return;
        cout << root->value << ' ';
        if (heightHelper(root->left) > heightHelper(root->right)) {
            printMaxPathHelper(root->left);
        }
        else {
            printMaxPathHelper(root->right);
        }
    }

    bool deleteValueHelper(Node<T>* parent, Node<T>* current, T value) {
        if (!current) return false;
        if (current->value == value) {
            if (current->left == NULL || current->right == NULL) {
                Node<T>* temp = current->left;
                if (current->right) temp = current->right;
                if (parent) {
                    if (parent->left == current) {
                        parent->left = temp;
                    }
                    else {
                        parent->right = temp;
                    }
                }
                else {
                    this->root = temp;
                }
            }
            else {
                Node<T>* validSubs = current->right;
                while (validSubs->left) {
                    validSubs = validSubs->left;
                }
                T temp = current->value;
                current->value = validSubs->value;
                validSubs->value = temp;
                return deleteValueHelper(current, current->right, temp);
            }
            delete current;
            return true;
        }
        return deleteValueHelper(current, current->left, value) ||
            deleteValueHelper(current, current->right, value);
    }

public:

    void insert(T val) {
        if (root) {
            this->addHelper(root, val);
        }
        else {
            root = new Node<T>(val);
        }
    }

    void print() {
        printHelper(this->root);
    }

    int nodesCount() {
        return nodesCountHelper(root);
    }

    int height() {
        return heightHelper(this->root);
    }

    void printMaxPath() {
        printMaxPathHelper(this->root);
    }

    bool Delete(T value) {
        return this->deleteValueHelper(NULL, this->root, value);
    }
};
#endif

I created the struct using these 3 values, and a pointer to a right and left node, however, all my other functions don't seem to work with the age and name values, only the ID. This is most problamatic in my add and print function.

I'm relatively new to C++, so any help would be appreciated.

EDIT: I'm assuming my problem lies around here somewhere. The code runs just fine, but it doesn't add the age and name to the string, and I can't properly print these values, just the ID

 Node<T> *root;

    void addHelper(Node<T> *root, T val) {
        if (root->value > val) {
            if (!root->left) {
                root->left = new Node<T>(val);
            }
            else {
                addHelper(root->left, val);**
            }
        }
        else {
            if (!root->right) {
                root->right = new Node<T>(val);
            }
            else {
                addHelper(root->right, val);
            }
        }
    }

and here

void printHelper(Node<T> *root) {
        if (!root) return;
        printHelper(root->left);
        cout << root->value << ' ';
        cout << root->age << ' '; // ADDED
        cout << root->name << ' '; //ADDED
        printHelper(root->right);
    }

Thanks in advance!

Answer 1

root->left = new Node(val);

root->right = new Node(val);

It seems that you create a new node and only give it a "val", no age, no name etc, so it only has the value.

edit: I never used "Template" before, so it took me a while to figure it out. Anyways...

Solution: When you insert a node, you need to copy all the information, not just the "value", otherwise you'll only get the "value".

void addHelper(Node<T> *root, Node<T>* n) {
    if (root->value > n->value) {
        if (!root->left) {
            root->left = new Node<T>(n->value,n->age,n->name,NULL,NULL);
        }
        else {
            addHelper(root->left, n);
        }
    }
    else {
        if (!root->right) {
            root->right = new Node<T>(n->value,n->age,n->name,NULL,NULL);
        }
        else {
            addHelper(root->right, n);
        }
    }
}

Also in "insert":

void insert(Node<T>* n) {
    if (root) {
        this->addHelper(root, n);
    }
    else {
        root = new Node<T>(n->value,n->age,n->name,NULL,NULL);
    }
}

Several other things you may try and see the difference:

I would initialize *root to be NULL, otherwise it may be some random stuff, and sometime I got seg fault because of that.

class BST {

private:
    Node<T> *root=NULL;

If the node you're about to insert has the same "value" with an already existing node, what do you do? Your program will just add it to the right. I don't know if that's what you want, but that's what it will do.

I tested with this and it worked. Hope it will work for you, too.

int main(){
    BST<int> tree;
    Node<int> node1(1,10,"test1",NULL,NULL);
    Node<int> node2(5,50,"test2",NULL,NULL);
    Node<int> node3(3,30,"test3",NULL,NULL);
    Node<int> node4(3,30,"test4",NULL,NULL);
    Node<int> node5(3,30,"test5",NULL,NULL);
    Node<int> node6(8,80,"test5",NULL,NULL);
    tree.insert(&node1);
    tree.insert(&node2);
    tree.insert(&node3);
    tree.insert(&node4);
    tree.insert(&node5);
    tree.insert(&node6);
    tree.print();
    cout<<endl;
    return 0;
}

output:

1 10 test1 3 30 test3 3 30 test4 3 30 test5 5 50 test2 8 80 test5