binary search tree in c++

Comment

3

// C++ program to demonstrate insertion
// in a BST recursively.
#include <iostream>
using namespace std;
 
class BST {
    int data;
    BST *left, *right;
 
public:
    // Default constructor.
    BST();
 
    // Parameterized constructor.
    BST(int);
 
    // Insert function.
    BST* Insert(BST*, int);
 
    // Inorder traversal.
    void Inorder(BST*);
};
 
// Default Constructor definition.
BST ::BST()
    : data(0)
    , left(NULL)
    , right(NULL)
{
}
 
// Parameterized Constructor definition.
BST ::BST(int value)
{
    data = value;
    left = right = NULL;
}
 
// Insert function definition.
BST* BST ::Insert(BST* root, int value)
{
    if (!root) {
        // Insert the first node, if root is NULL.
        return new BST(value);
    }
 
    // Insert data.
    if (value > root->data) {
        // Insert right node data, if the 'value'
        // to be inserted is greater than 'root' node data.
 
        // Process right nodes.
        root->right = Insert(root->right, value);
    }
    else if (value < root->data){
        // Insert left node data, if the 'value'
        // to be inserted is smaller than 'root' node data.
 
        // Process left nodes.
        root->left = Insert(root->left, value);
    }
 
    // Return 'root' node, after insertion.
    return root;
}
 
// Inorder traversal function.
// This gives data in sorted order.
void BST ::Inorder(BST* root)
{
    if (!root) {
        return;
    }
    Inorder(root->left);
    cout << root->data << endl;
    Inorder(root->right);
}

Popularity 10/10 Helpfulness 2/10 Language cpp

Source: www.geeksforgeeks.org

Tags: binary-search-tree c++

Share

Link to this answer
Share Copy Link

Contributed on Nov 04 2022

Smoggy Snake

0 Answers Avg Quality 2/10

m way search tree in c++

Comment

0

#include<iostream>
using namespace std;

struct mWay{
    int index=-1;
    static const int m=3;
    int k[m-1];
    mWay *child[m]={NULL};
};

mWay* createNode(int value){
    mWay *node=new mWay;
    (node->index)++;
    node->k[node->index]=value;
    return node;
}

void sorting(mWay *s){      //using bubble sort..
    int temp;
    for(int i=0;i<(s->index);i++){
        for(int j=0;j<(s->index);j++){
            if((s->k[j])>(s->k[j+1])){
                temp=(s->k[j]);
                (s->k[j])=(s->k[j+1]);
                (s->k[j+1])=temp;
            }
        }
    }
}

mWay* Insert(int data,mWay *root){
    if(root==NULL){         //creating a new mWay tree...
        root=createNode(data);
        return root;
    }
    else{                   //updating the mWay tree...
        mWay *ptr=root;
        mWay *par=NULL;
        int store;          //we will store the index of next child node in this variable (in the last case)...
        while(ptr!=NULL){
            par=ptr;
            if((ptr->index)<(ptr->m)-2){    //checking to see if we can insert more keys in the current node...
                (ptr->index)++;
                ptr->k[ptr->index]=data;
                sorting(ptr);               //sorting keys..
                return root;
            }
            else{       //we have to move to the next node..
                if(data<ptr->k[0]){     //if the data is smaller than the first key of the node then we move towards the first child...
                    ptr=ptr->child[0];
                }
                else if(data>ptr->k[(ptr->m)-2]){       //if the data is greater than the last node then we move towards the last child...
                    ptr=ptr->child[(ptr->m)-1];
                }
                else{       //according to the property we check accordingly if the value ranges between the values of two keys ...
                    for(int i=1;i<(ptr->m)-1;i++){
                        if(data>(ptr->k[i-1]) && data<(ptr->k[i])){
                            store=i;
                            ptr=ptr->child[i];
                            break;
                        }
                    }
                }
            }
        }   //end of while loop which means we just have to insert the node now...
        if(data<(par->k[0])){
            par->child[0]=createNode(data);
        }
        else if(data>(par->k[(par->m)-2])){
            par->child[(par->m)-1]=createNode(data);
        }
        else{
            par->child[store]=createNode(data);
        }
        return root;
    }
}

Popularity 6/10 Helpfulness 2/10 Language cpp

Source: codereview.stackexchange.com

Tags: c++ m search-tree

Share

Link to this answer
Share Copy Link

Contributed on Oct 30 2022

Anurup Mondal

0 Answers Avg Quality 2/10

Binary Search Tree

Comment

1

# Tree traversal in Python


class Node:
    def __init__(self, item):
        self.left = None
        self.right = None
        self.val = item


def inorder(root):

    if root:
        # Traverse left
        inorder(root.left)
        # Traverse root
        print(str(root.val) + "->", end='')
        # Traverse right
        inorder(root.right)


def postorder(root):

    if root:
        # Traverse left
        postorder(root.left)
        # Traverse right
        postorder(root.right)
        # Traverse root
        print(str(root.val) + "->", end='')


def preorder(root):

    if root:
        # Traverse root
        print(str(root.val) + "->", end='')
        # Traverse left
        preorder(root.left)
        # Traverse right
        preorder(root.right)


root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)

print("Inorder traversal ")
inorder(root)

print("\nPreorder traversal ")
preorder(root)

print("\nPostorder traversal ")
postorder(root)

Popularity 10/10 Helpfulness 1/10 Language python

Source: www.programiz.com

Tags: binary-search-tree binary-search-tre

Share

Link to this answer
Share Copy Link

Contributed on Jan 31 2022

Bored Bat

0 Answers Avg Quality 2/10

binary search tree

Comment

0

// Java program to demonstrate
// insert operation in binary
// search tree
class BinarySearchTree {
 
    /* Class containing left
       and right child of current node
     * and key value*/
    class Node {
        int key;
        Node left, right;
 
        public Node(int item)
        {
            key = item;
            left = right = null;
        }
    }
 
    // Root of BST
    Node root;
 
    // Constructor
    BinarySearchTree() { root = null; }
 
    BinarySearchTree(int value) { root = new Node(value); }
 
    // This method mainly calls insertRec()
    void insert(int key) { root = insertRec(root, key); }
 
    /* A recursive function to
       insert a new key in BST */
    Node insertRec(Node root, int key)
    {
 
        /* If the tree is empty,
           return a new node */
        if (root == null) {
            root = new Node(key);
            return root;
        }
 
        /* Otherwise, recur down the tree */
        else if (key < root.key)
            root.left = insertRec(root.left, key);
        else if (key > root.key)
            root.right = insertRec(root.right, key);
 
        /* return the (unchanged) node pointer */
        return root;
    }
 
    // This method mainly calls InorderRec()
    void inorder() { inorderRec(root); }
 
    // A utility function to
    // do inorder traversal of BST
    void inorderRec(Node root)
    {
        if (root != null) {
            inorderRec(root.left);
            System.out.println(root.key);
            inorderRec(root.right);
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        BinarySearchTree tree = new BinarySearchTree();
 
        /* Let us create following BST
              50
           /     \
          30      70
         /  \    /  \
       20   40  60   80 */
        tree.insert(50);
        tree.insert(30);
        tree.insert(20);
        tree.insert(40);
        tree.insert(70);
        tree.insert(60);
        tree.insert(80);
 
        // print inorder traversal of the BST
        tree.inorder();
    }
}
// This code is contributed by Ankur Narain Verma

Popularity 10/10 Helpfulness 1/10 Language java

Source: www.geeksforgeeks.org

Tags: binary-search-tree binary-search-tre

Share

Link to this answer
Share Copy Link

Contributed on Aug 18 2022

Andrea wong

0 Answers Avg Quality 2/10

binary search tree

Comment

0

Binary Search Tree is a node-based binary tree data structure which has the following properties:

The left subtree of a node contains only nodes with keys lesser than the node’s key.
The right subtree of a node contains only nodes with keys greater than the node’s key.
The left and right subtree each must also be a binary search tree.

Popularity 10/10 Helpfulness 1/10 Language shell

Source: Grepper

Tags: binary-search-tree binary-search-tre

Share

Link to this answer
Share Copy Link

Contributed on Sep 01 2022

DevRedoy

0 Answers Avg Quality 2/10

binary search tree

Comment

0

Binary Search Tree is a node-based binary tree data structure which has the following properties:

The left subtree of a node contains only nodes with keys lesser than the node’s key.
The right subtree of a node contains only nodes with keys greater than the node’s key.
The left and right subtree each must also be a binary search tree.

Popularity 10/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: binary-search-tree binary-search-tre

Share

Link to this answer
Share Copy Link

Contributed on Dec 09 2020

Frightened Ferret

0 Answers Avg Quality 2/10

Binary Search Tree

Comment

0

//Java Binary Search Tree with In-Order, Pre-Order and Post-Order Traversals
public class BinarySearchTree {
    public static void main(String[] args) {
        searchSolution s = new searchSolution();

        s.insertionkey('J');
        s.insertionkey('B');
        s.insertionkey('E');
        s.insertionkey('C');
        s.insertionkey('G');
        s.insertionkey('A');
        s.insertionkey('H');
        s.insertionkey('I');
        s.insertionkey('D');
        s.insertionkey('F');

        System.out.println("IN ORDER Search");
        s.InOrderTraversal(s.root);
        System.out.println();
        System.out.println();

        System.out.println("PRE ORDER Search");
        s.PreOrderTraversal(s.root);
        System.out.println();
        System.out.println();

        System.out.println("POST ORDER Search");
        s.PostOrderTraversal(s.root);
    }

}

class searchSolution {
    node root;

    void insertionkey(char key) {
        root = insertionInTree(root, key);
    }

    node insertionInTree(node root, char key) {
        if (root == null) {
            root = new node(key);
            return root;
        }

        if (key < root.key) {
            root.left = insertionInTree(root.left, key);
        } else if (key > root.key) {
            root.right = insertionInTree(root.right, key);
        }
        return root;
    }

    void InOrderTraversal(node n) {
        // InOrder Traversal = Left Root Right
        if (n != null) {
            InOrderTraversal(n.left);
            System.out.print(n.key + " ");
            InOrderTraversal(n.right);
        }
    }

    void PreOrderTraversal(node n) {
        // PreOrder Traversal = Root Left Right
        if (n != null) {
            System.out.print(n.key + " ");
            PreOrderTraversal(n.left);
            PreOrderTraversal(n.right);
        }
    }

    void PostOrderTraversal(node n) {
        // PostOrder Traversal = Left Right Root
        if (n != null) {
            PostOrderTraversal(n.left);
            PostOrderTraversal(n.right);
            System.out.print(n.key + " ");
        }
    }
}

class node { 
    char key;
    node left, right;

    node(char KEY) {
        this.key = KEY;
    }
}

Popularity 10/10 Helpfulness 1/10 Language java

Source: Grepper

Tags: binary-search-tree binary-search-tre

Share

Link to this answer
Share Copy Link

Contributed on Jul 18 2022

Wild Wolverine

0 Answers Avg Quality 2/10

Binary Search Tree

Comment

0

A binary tree is said to be a binary search tree if for every node, the left is smaller than it and the right is bigger than it. 

Example
       10
    9      20
  6  11   13  26

For example, try looking for 13 and 26.
13 is larger than 10, so go to the right.
13 is smaller than 20, so go to the left.

26 is larger than 10, so go to the right.
26 is larger than 20, so go to the right.

Popularity 10/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: binary-search-tree binary-search-tre

Share

Link to this answer
Share Copy Link

Contributed on Jul 19 2022

Javasper

0 Answers Avg Quality 2/10

binary search tree

Comment

0

//
// 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 9/10 Helpfulness 1/10 Language javascript

Source: Grepper

Tags: binary-search-tree binary-search-tre

Share

Link to this answer
Share Copy Link

Contributed on Aug 26 2023

Mero

0 Answers Avg Quality 2/10

binary search tree

Comment

1

# Driver Code 
arr = [ 2, 3, 4, 10, 40 ] 
x = 10
  
# Function call 
result = binarySearch(arr, 0, len(arr)-1, x) 
  
if result != -1: 
    print ("Element is present at index % d" % result) 
else: 
    print ("Element is not present in array")

Popularity 10/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: binary-search-tree binary-search-tre

Share

Link to this answer
Share Copy Link

Contributed on Dec 09 2020

Frightened Ferret

0 Answers Avg Quality 2/10

binary search tree in c++

Contents

More Related Answers

binary search tree in c++

Closely Related Answers

m way search tree in c++

Binary Search Tree

binary search tree

binary search tree

binary search tree

Binary Search Tree

Binary Search Tree

binary search tree

binary search tree

Grepper

Documentation

Social

Legal

Contact

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