Hey if you new to programming and you came straight to Data Structures and Algorithms. And you have selected the c++ as your partner in this journey. Well then don't worry Data Structures and Algorithms are not hard to understand with c++. 

    I think it is easy in c++ to learn Data Structures and Algorithms. It's simple object oriented way of doing things. And If you know even a little bit of OOP you will be able to understand it very well.

Binary Tree In C++

    In this article we making a binary tree in C++ OOP way. So this file will have a node class which will be our node or vertex. And a binary tree class which will be the collection of these nodes or vertex. Where main operations of the binary will be performed.

    Below are some methods that we will implement in the binary tree.

• insert() - to insert the data in the tree
• printInorder() - to print the tree inorder traversal
• printPreOrder() - to print the tree in PreOrder traversal
• printPostOrder() - to print the tree in PostOrder traversal
• printLevelOrder() - to print the tree in Level order traversal
• height() - to find the height of the tree

#include<iostream>
#include<queue>
class Node{
    public:
        int data;
        Node *left;
        Node *right;
    Node(int data){
        this->data = data;
        this->left = NULL;
        this->right = NULL;
    }
};

class BinaryTree{
    public:
        Node *root;
    BinaryTree(){
        this->root = NULL;
    }
    void insert(int data){
        Node *newNode = new Node(data);
        if(this->root == NULL){
            this->root = newNode;
        }else{
            Node *current = this->root;
            while(current != NULL){
                if(data < current->data){
                    if(current->left == NULL){
                        current->left = newNode;
                        break;
                    }else{
                        current = current->left;
                    }
                }else{
                    if(current->right == NULL){
                        current->right = newNode;
                        break;
                    }else{
                        current = current->right;
                    }
                }
            }
        }
    }
    // inorder traversal
    void printInOrder(Node *root){
        if(root != NULL){
            printInOrder(root->left);
            std::cout<<root->data<<" ";
            printInOrder(root->right);
        }
    }
    // print the tree in preorder traversal
    void printPreOrder(Node *root){
        if(root != NULL){
            std::cout<<root->data<<" ";
            printPreOrder(root->left);
            printPreOrder(root->right);
        }
    }
    // print post order
    void printPostOrder(Node *root){
        if(root != NULL){
            printPostOrder(root->left);
            printPostOrder(root->right);
            std::cout<<root->data<<" ";
        }
    }
    // level order traversal
    void printLevelOrder(Node *root){
        if(root != NULL){
            std::queue<Node *> q;
            q.push(root);
            while(!q.empty()){
                Node *current = q.front();
                q.pop();
                std::cout<<current->data<<" ";
                if(current->left != NULL){
                    q.push(current->left);
                }
                if(current->right != NULL){
                    q.push(current->right);
                }
            }
        }
    }
    // finding the height of the tree
    int height(Node *root){
        if(root == NULL){
            return 0;
        }else{
            int lheight = height(root->left);
            int rheight = height(root->right);
            if(lheight > rheight){
                return lheight + 1;
            }else{
                return rheight + 1;
            }
        }
    }
};

int main(){
    // creating a binary tree
    BinaryTree *tree = new BinaryTree();
    // take input from the user
    int noOfNodes;
    std::cout<<"Enter the number of nodes: ";
    std::cin>>noOfNodes;
    for (int i = 0; i < noOfNodes; i++){
        int data;
        std::cout<<"Enter data at node "<<i+1<<": ";
        std::cin>>data;
        tree->insert(data);
    }
    // print the tree in inorder
    std::cout<<"The tree inorder traversal is: ";
    tree->printInOrder(tree->root);
    std::cout << std::endl;

    // print the tree in preorder
    std::cout<<"The tree preorder traversal is: ";
    tree->printPreOrder(tree->root);
    std::cout << std::endl;

    // print the tree in postorder
    std::cout<<"The tree postorder traversal is: ";
    tree->printPostOrder(tree->root);
    std::cout << std::endl;

    // print the tree in levelorder
    std::cout<<"The tree level order traversal is: ";
    tree->printLevelOrder(tree->root);
    std::cout << std::endl;

    // print the height of the tree
    std::cout << "The height of the tree is: "<<tree->height(tree->root);
    std::cout << std::endl;
    
    system("pause");
    return 0;
}

output:

    

output