Binary tree

class Node:
    def __init__(self,key):
        self.left = None
        self.right = None
        self.val = key
 
root = Node(1)
root.left      = Node(2);
root.right     = Node(3);
root.left.left  = Node(4);

Binary tree

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DataStructure
{
    namespace Tree
    {
        internal class BinaryTree
        {
            private Node root;
            public void Insert(int data)
            {
                var node = new Node(data);
                if (root == null)
                {
                    root = node;
                    return;
                }

                var current = root;

                while (true)
                {
                    if (current.data > data)
                    {
                        if (current.leftChild == null)
                        {
                            current.leftChild = node;
                            break;
                        }
                        current = current.leftChild;
                    }
                    else if (current.data < data)
                    {
                        if (current.rightChild == null)
                        {
                            current.rightChild = node;
                            break;
                        }
                        current = current.rightChild;
                    }
                }
            }
            public void InOrder()
            {
                InOrder(root);
            }
            public void PreOrder()
            {
                InOrder(root);
            }
            public void PostOrder()
            {
                InOrder(root);
            }
            private void InOrder(Node node)
            {
                if (node == null)
                    return;
                InOrder(node.leftChild);
                Console.Write(node.data);
                InOrder(node.rightChild);
            }
            private void PreOrder(Node node)
            {
                if (node == null)
                    return;
                Console.Write(node.data);
                PreOrder(node.leftChild);
                PreOrder(node.rightChild);
            }
            private void PostOrder(Node node)
            {
                if (node == null)
                    return;
                PostOrder(node.leftChild);
                PostOrder(node.rightChild);
                Console.Write(node.data);
            }

            public int Height()
            {
                return Height(root);
            }
            private int Height(Node node)
            {
                if (node == null)
                {
                    return -1;
                }
                if (IsLeaf(node))
                {
                    return 0;
                }
                return 1 + Math.Max(Height(node.leftChild), Height(node.rightChild));
            }
            private bool IsLeaf(Node node)
            {
                if (node.leftChild == null && node.rightChild == null)
                {
                    return true;
                }
                return false;
            }

            public bool IsEqual(Node first, Node second)
            {
                if (first == null && second == null)
                    return true;
                if (first != null && second != null)
                {
                    return first.data == second.data &&
                        IsEqual(first.rightChild, second.rightChild) &&
                        IsEqual(first.leftChild, second.leftChild);
                }
                return false;
            }
        }
        public class Node
        {
            public int data;
            public Node leftChild;
            public Node rightChild;
            public Node(int data)
            {
                this.data = data;
            }
        }
    }
}

Binary tree

#include <iostream>
#include <queue>
using namespace std;
struct Node{
   int data;
   struct Node* left, *right;
};
// Function to count the full Nodes in a binary tree
int fullcount(struct Node* node){
   // Check if tree is empty
   if (!node){
      return 0;
   }  
   queue<Node *> myqueue;
   // traverse using level order traversing
   int result = 0;
   myqueue.push(node);
   while (!myqueue.empty()){
      struct Node *temp = myqueue.front();
      myqueue.pop();
      if (temp->left && temp->right){
         result++;
      }
      if (temp->left != NULL){
         myqueue.push(temp->left);
      }
      if (temp->right != NULL){
         myqueue.push(temp->right);
      }
   }
   return result;
}
struct Node* newNode(int data){
   struct Node* node = new Node;
   node->data = data;
   node->left = node->right = NULL;
   return (node);
}
int main(void){
   struct Node *root = newNode(10);
   root->left = newNode(20);
   root->right = newNode(30);
   root->left->left = newNode(40);
   root->left->right = newNode(50);
   root->left->left->right = newNode(60);
   root->left->right->right = newNode(70);
   cout <<"count is: "<<fullcount(root);
   return 0;
}

Similar codes

1 vote321 views2 answers
How to get user id django
Python
-1 vote340 views1 answer
Armstrong number function
Python
0 vote322 views1 answer
Check prime number in python
Python
3 votes335 views2 answers
Cyclically rotate an array by one
Python
0 vote345 views1 answer
Pandas column string first n characters
Python
2 votes326 views1 answer
Pandas pass two columns to function
Python
0 vote328 views1 answer
Printing hollow triangle in python
Python
8 votes319 views2 answers
Purpose of meta class in django
Python
5 votes338 views1 answer
Python string replace index
Python
1 vote331 views2 answers
Rename files in a folder python
Python