Add files via upload

add

Author: nsgowebjavaprog

F-Tree/Daimeter.java

@@ -0,0 +1,19 @@
+class Solution {
+    // Function to return the diameter of a Binary Tree.
+    int diameter(Node root) {
+        // Your code here
+        int max[] = new int[1];
+        height(root, max);
+        return (max[0]);
+    }
+    private int height(Node node, int max[]){
+        if(node == null) {
+            return 0;
+        }
+        int l = height(node.left, max);
+        
+        int r = height(node.right, max);
+        max[0] = Math.max(max[0], l+r);
+        return 1+Math.max(l,r);
+    }
+}

F-Tree/Height_Of_Tree.java

@@ -0,0 +1,34 @@
+/*
+Height of Binary Tree
+Difficulty: EasyAccuracy: 78.58%Submissions: 293K+Points: 2
+Given a binary tree, find its height.
+
+The height of a tree is defined as the number of edges on the longest path from the root to a leaf node. A leaf node is a node that does not have any children.
+
+Examples:
+
+Input: root[] = [12, 8, 18, 5, 11] 
+ 
+Output: 2
+Explanation: The longest path from the root (node 12) goes through node 8 to node 5, which has 2 edges.
+*/
+
+import org.w3c.dom.Node;
+
+class Solution {
+    // Function to find the height of a binary tree.
+    int height(Node node) {
+        // code here 
+        if (node == null) {
+            return 0;
+        }
+        if (node != null && node.left == null && node.right==null) {
+            return 0;
+        }
+        
+        int leftH = height(node.left);
+        int rightH = height(node.right);
+        
+        return Math.max(leftH, rightH) + 1;
+    }
+}

F-Tree/InOrder.java

@@ -0,0 +1,46 @@
+
+/*
+                                                           1. Inorder Traversal
+Difficulty: BasicAccuracy: 67.15%Submissions: 162K+Points: 1
+Given a Binary Tree, find the In-Order Traversal of it.
+
+Examples:
+
+Input:
+       1
+     /  \
+    3    2
+Output: [3, 1, 2]
+Explanation: The in-order traversal of the given binary tree is [3, 1, 2].
+Input:
+        10
+     /      \ 
+    20       30 
+  /    \    /
+ 40    60  50
+Output: [40, 20, 60, 10, 50, 30]
+Explanation: The in-order traversal of the given binary tree is [40, 20, 60, 10, 50, 30].
+ */
+import java.util.*;
+
+import org.w3c.dom.Node;
+
+class Solution {
+
+    void inorder(Node root, ArrayList<Integer> ans) {
+        if (root == null) {
+            return;
+        }
+        inorder(root.left, ans);
+        ans.add(root.data);
+        inorder(root.right, ans);
+    }
+
+    // Function to return a list containing the inorder traversal of the tree.
+    ArrayList<Integer> inOrder(Node root) {
+        ArrayList<Integer> ans = new ArrayList<>();
+        inorder(root, ans);
+        return ans;
+
+    }
+}

F-Tree/Is_Tree_Is_Correct.java

@@ -0,0 +1,14 @@
+class Solution {
+    // Function to check whether a Binary Tree is BST or not.
+    boolean isBST(Node root) {
+        // code here.
+        int min = Integer.MIN_VALUE;
+        int max = Integer.MAX_VALUE;
+        return bst(root, min, max);
+    }
+    public static boolean bst(Node root, int min, int max){
+        if(root == null) return true;
+        if(root.data <= min || root.data >= max) return false;
+        return bst(root.left, min, root.data) && bst(root.right, root.data, max);
+    }
+}

F-Tree/Kth_Large_Num.java

@@ -0,0 +1,58 @@
+// ----> return as.get(as.size() - K): Returns the kth largest element, which is the element at index as.size() - K in the sorted ArrayList.
+
+/*
+                                                3.  Kth largest element in BST
+Difficulty: EasyAccuracy: 49.31%Submissions: 161K+Points: 2
+Given a Binary Search Tree. Your task is to complete the function which will return the kth largest element without doing any modification in the Binary Search Tree.
+
+Examples:
+
+1. Input:
+      4
+    /   \
+   2     9
+k = 2 
+Output: 4
+Explanation: 2nd Largest element in BST is 4
+
+
+2. Input:
+       9
+        \ 
+          10
+k = 1
+Output: 10
+Explanation: 1st Largest element in BST is 10
+
+
+3. Input:
+      4
+    /   \
+   2     9
+k = 3 
+Output: 2
+Explanation: 3rd Largest element in BST is 2
+ */
+
+import java.util.ArrayList;
+
+import org.w3c.dom.Node;
+
+class Solution {
+    void check(Node root, ArrayList<Integer> ans) {
+        if (root == null) {
+            return;
+        }
+        check(root.left, ans);
+        ans.add(root.data);
+        check(root.right, ans);
+    }
+
+    // return the Kth largest element in the given BST rooted at 'root'
+    public int kthLargest(Node root, int k) {
+        // Your code here
+        ArrayList<Integer> ans = new ArrayList<>();
+        check(root, ans);
+        return ans.get(ans.size() - k);
+    }
+}

F-Tree/Left_View.java

@@ -0,0 +1,35 @@
+/*
+ Left View of Binary Tree
+Difficulty: EasyAccuracy: 33.74%Submissions: 532K+Points: 2
+You are given the root of a binary tree. Your task is to return the left view of the binary tree. The left view of a binary tree is the set of nodes visible when the tree is viewed from the left side.
+
+If the tree is empty, return an empty list.
+
+Examples :
+
+Input: root[] = [1, 2, 3, 4, 5, N, N]
+
+Output: [1, 2, 4]
+Explanation: From the left side of the tree, only the nodes 1, 2, and 4 are visible.
+ 
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+class Solution {
+    void resultView(Node root, int level, List<Integer> res) {
+        if (root == null) return;
+        if (res.size() == level) res.add(root.data);
+        resultView(root.left, level + 1, res);
+        resultView(root.right, level + 1, res);
+    }
+
+    List<Integer> leftView(Node root) {
+        List<Integer> res = new ArrayList<>();
+        resultView(root, 0, res);
+        return res;
+    }
+
+}

F-Tree/PreOrder.java

@@ -0,0 +1,54 @@
+/*
+                                                        2. Preorder Traversal
+
+ Given a binary tree, find its preorder traversal.
+
+Examples:
+
+Input:
+        1      
+      /          
+    4    
+  /    \   
+4       2
+Output: [1, 4, 4, 2]
+Input:
+       6
+     /   \
+    3     2
+     \   / 
+      1 2
+Output: [6, 3, 1, 2, 2] 
+Input:
+         8
+       / \
+      3   10
+     / \    \
+    1   6   14
+       / \   /
+      4   7 13
+Output: [8, 3, 1, 6, 4, 7, 10, 14, 13]
+ */
+
+import java.util.ArrayList;
+
+import org.w3c.dom.Node;
+
+class Solution {
+    void PreOrder(Node root, ArrayList<Integer> ans) {
+        if (root == null) {
+            return;
+        }
+        ans.add(root.data);
+        PreOrder(root.left, ans);
+        PreOrder(root.right, ans);
+    }
+
+    // Function to return a list containing the preorder traversal of the tree.
+    ArrayList<Integer> preorder(Node root) {
+        // write code here
+        ArrayList<Integer> ans = new ArrayList<>();
+        PreOrder(root, ans);
+        return ans;
+    }
+}

F-Tree/Right_View.java

@@ -0,0 +1,34 @@
+/*
+ Right View of Binary Tree
+
+ Given a Binary Tree, Your task is to return the values visible from Right view of it.
+
+Right view of a Binary Tree is set of nodes visible when tree is viewed from right side.
+
+Examples :
+
+Input: root = [1, 2, 3, 4, 5]
+     2_2
+Output: [1, 3, 5]
+
+*/
+
+class Solution {
+    // Function to return list containing elements of right view of binary tree.
+    ArrayList<Integer> rightView(Node root) {
+        ArrayList<Integer> list = new ArrayList<Integer>();
+        right_view(root, list, 0);
+        return list;
+    }
+
+    private void right_view(Node root, ArrayList<Integer> list, int curr_level) {
+        if (root == null)
+            return;
+        if (curr_level == list.size()) {
+            list.add(root.data);
+        }
+        right_view(root.right, list, curr_level + 1);
+        right_view(root.left, list, curr_level + 1);
+    }
+
+}