Difference between Binary Search Tree and Binary Heap

1. Binary Search Tree :
An acyclic graph is commonly used to illustrate a Binary Search Tree. The tree is made up of nodes. Each node in a binary tree has no more than two children. Every node's value is strictly higher than the value of its left child and strictly lower than the value of its right child, according to the BST. That is, we can iterate through all of the BST values in sorted order. Additionally, duplicate values are not permitted in this data structure.

There are two types of Binary Search Trees: balanced and unbalanced.

Assume that the number of nodes in a BST is n. O(n) is the worst case scenario for insert and removal operations. However, in a balanced Binary Search Tree, such as AVL or Red-Black Tree, similar operations have a time complexity of O(log(n)). Another important point to remember is that constructing a BST with n nodes takes O(n * log(n)) time. We must insert a node n times, each of which costs O(log(n)). The main benefit of a Binary Search Tree is that we can traverse it in O(n) time and receive all of our values in sorted order.

Code:

#include <iostream>
using namespace std;

// Node structure
struct Node {
    int data;
    Node* left;
    Node* right;

    Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

// BST class
class BST {
public:
    BST() : root(nullptr) {}

    // Function to insert a node
    void insert(int val) {
        root = insertRec(root, val);
    }

    // Function to search for a node
    bool search(int val) {
        return searchRec(root, val);
    }

    // Function to print inorder traversal
    void inorder() {
        inorderRec(root);
        cout << endl;
    }

private:
    Node* root;

    // Recursive function to insert a node
    Node* insertRec(Node* node, int val) {
        // If the tree is empty, return a new node
        if (node == nullptr) {
            return new Node(val);
        }

        // Otherwise, recur down the tree
        if (val < node->data) {
            node->left = insertRec(node->left, val);
        } else if (val > node->data) {
            node->right = insertRec(node->right, val);
        }

        // Return the (unchanged) node pointer
        return node;
    }

    // Recursive function to search a node
    bool searchRec(Node* node, int val) {
        // Base cases: node is null or value is present at node
        if (node == nullptr || node->data == val) {
            return node != nullptr;
        }

        // Value is greater than node's data
        if (val > node->data) {
            return searchRec(node->right, val);
        }

        // Value is smaller than node's data
        return searchRec(node->left, val);
    }

    // Recursive function for inorder traversal
    void inorderRec(Node* node) {
        if (node == nullptr) {
            return;
        }

        // Recur on left child
        inorderRec(node->left);

        // Print node's data
        cout << node->data << " ";

        // Recur on right child
        inorderRec(node->right);
    }
};

int main() {
    BST tree;
    // Inserting nodes into the BST
    tree.insert(8);
    tree.insert(3);
    tree.insert(10);
    tree.insert(1);
    tree.insert(6);
    tree.insert(14);
    tree.insert(4);
    tree.insert(7);
    tree.insert(13);

    // Printing inorder traversal
    cout << "Inorder traversal of the BST: ";
    tree.inorder();

    // Searching for values in the BST
    cout << "Searching for 10 in the BST: " << (tree.search(10) ? "Found" : "Not Found") << endl;
    cout << "Searching for 5 in the BST: " << (tree.search(5) ? "Found" : "Not Found") << endl;

    return 0;
}

Inorder traversal of the BST: 1 3 4 6 7 8 10 13 14 
Searching for 10 in the BST: Found
Searching for 5 in the BST: Not Found

2. Heap Tree :
The Heap is a Complete Binary Tree.
If the distance between a node and the root node is k, the node is at level k of the tree. The root's level is zero. At level k, the maximum number of nodes that can exist is 2^k. A Complete Binary Tree has the maximum number of nodes at each level. Except for the last layer, which must be filled from left to right as well. It's critical to remember that the Complete Binary Tree is always balanced.

The Heap is not the same as a Binary Search Tree. The Heap, on the other hand, is not an ordered data structure. The heap is commonly represented as an array of numbers in computer memory. It's possible to have a Min-Heap or a Max-Heap heap. Although the features of the Min- and Max-Heaps are nearly identical, the root of the tree for the Max-Heap is the biggest number and the smallest for the Min-Heap. Similarly, the basic rule of the Max-Heap is that each node's subtree has values that are less than or equal to the root node. The Min-Heap, on the other hand, is the polar opposite. It also implies that the Heap accepts duplicates.

Binary Search Tree vs Heap :
The fundamental distinction is that whereas the Binary Search Tree does not allow duplicates, the Heap allows. The BST is ordered, while Heap is not.  So, if order is important, BST is the way to go. If an order isn't important, but we need to know that inserting and removing data will take O(log(n)) time, the Heap assures that this will happen. If the tree is fully unbalanced, this might take up to O(n) time in a Binary Search Tree (chain is the worst case). In addition, although Heap may be built in linear time, the BST requires O(n * log(n)) to be built.

The PriorityQueue and TreeMap are Java's implementations of these structures. The backbone of TreeMap is a balanced binary search tree. A Red-Black Tree is used to implement it.