import [Link].

Scanner; boolean left =

[Link]();
class BinaryTree {
if (left) {
public BinaryTree() {
[Link]("Enter the
}
value of the left of " + [Link]);
private static class Node {
int value = [Link]();
int value;
[Link] = new Node(value);
Node left;
populate(scanner, [Link]);
Node right;
}
public Node(int value) {
[Link]("Do you want
[Link] = value; to enter right of " + [Link]);
} boolean right =
} [Link]();

private Node root; if (right) {

// insert elements [Link]("Enter the

value of the right of " + [Link]);
public void populate(Scanner
scanner) { int value = [Link]();

[Link]("Enter the root [Link] = new Node(value);

Node: "); populate(scanner, [Link]);
int value = [Link](); }
root = new Node(value); }
populate(scanner, root); public void display() {
} display([Link], "");
private void populate(Scanner }
scanner, Node node) {
private void display(Node node,
[Link]("Do you want String indent) {
to enter left of " + [Link]);
if (node == null) {
 return; public void preOrder() {
} preOrder(root);
[Link](indent + }
[Link]);
private void preOrder(Node node) {
display([Link], indent + "\t");
if (node == null) {
display([Link], indent + "\t");
return;
}
}
public void prettyDisplay() {
[Link]([Link] + "
prettyDisplay(root, 0); ");
} preOrder([Link]);
private void prettyDisplay(Node preOrder([Link]);
node, int level) {
}
if (node == null) {
public void inOrder() {
return;
preOrder(root);
}
}
prettyDisplay([Link], level +
private void inOrder(Node node) {
1);
if (node == null) {
if (level != 0) {
return;
for (int i = 0; i < level - 1; i++) {
}
[Link]("|\t\t");
preOrder([Link]);
}
[Link]([Link] + "
[Link]("|------->" +
");
[Link]);} else {
preOrder([Link]);
[Link]([Link]);}
}
prettyDisplay([Link], level + 1);
public void postOrder() {
}
preOrder(root);
 } private Node root;
private void postOrder(Node node) public BST() {
{
}
if (node == null) {
public int height(Node node) {
return;
if (node == null) {
}
return -1;}
preOrder([Link]);
return [Link]; }
preOrder([Link]);
public boolean isEmpty() {
[Link]([Link] + "
return root == null;
");
}
}
public void insert(int value) {
}
root = insert(value, root);
BST
}
class BST {
private Node insert(int value, Node
public class Node { node) { if (node == null) {
private int value; node = new Node(value);
private Node left; return node; }
private Node right; if (value < [Link]) {
private int height; [Link] = insert(value,
public Node(int value) { [Link]); }

[Link] = value; if (value > [Link]) {

} [Link] = insert(value,
[Link]);
public int getValue() {
}
return value;
[Link] =
}
[Link](height([Link]),
} height([Link])) + 1;
 return node; } balanced([Link]) &&
balanced([Link]); }
public void populate(int[] nums) {
public void display() {
for (int i = 0; i < [Link]; i++)
{ display([Link], "Root Node: ");
[Link](nums[i]); } } }
public void populatedSorted(int[] private void display(Node node,
nums) { String details) {
populatedSorted(nums, 0, if (node == null) {
[Link]); }
return;
private void populatedSorted(int[]
}
nums, int start, int end) {
[Link](details +
if (start >= end) {
[Link]);
return; }
display([Link], "Left child of " +
int mid = (start + end) / 2; [Link] + " : ");
[Link](nums[mid]); display([Link], "Right child of
" + [Link] + " : ");
populatedSorted(nums, start,
mid); }
populatedSorted(nums, mid + 1, MAIN FILE –
end); }
import [Link];
public boolean balanced() {
public class Main {
return balanced(root); }
public static void main(String[]
private boolean balanced(Node args) {
node) {
// Scanner scanner = new
if (node == null) { Scanner([Link]);
return true; } // BinaryTree tree = new
return [Link](height([Link]) BinaryTree();
- height([Link])) <= 1 && // [Link](scanner);
 // [Link](); return height(root);
}
BST tree = new BST(); private int height(Node node) {
int[] nums = { 5, 2, 7, 1, 4, 6, 9, 8, if (node == null) {
3, 10 };
return -1;
[Link](nums);
}
[Link]();
return [Link];
AVL –
}
class AVL {
public void insert(int value) {
public class Node {
root = insert(value, root);
private int value;
}
private Node left;
private Node insert(int value, Node
private Node right; node) {
private int height; if (node == null) {
public Node(int value) { node = new Node(value);
[Link] = value; return node;
} }
public int getValue() { if (value < [Link]) {
return value; [Link] = insert(value,
[Link]);
}
}
}
if (value > [Link]) {
private Node root;
[Link] = insert(value,
public AVL() {
[Link]);
}
}
public int height() {
 [Link] = if(height([Link]) -
[Link](height([Link]), height([Link]) < 0) {
height([Link])) + 1;
// right right case
return rotate(node);
return leftRotate(node);
}
}
if(height([Link]) -
private Node rotate(Node node) { height([Link]) > 0) {
if (height([Link]) - // left right case
height([Link]) > 1) {
[Link] =
// left heavy rightRotate([Link]);
if(height([Link]) - return leftRotate(node);
height([Link]) > 0) {
}
// left left case
return node;
return rightRotate(node);
}
}
public Node rightRotate(Node p) {
if(height([Link]) -
Node c = [Link];
height([Link]) < 0) {
Node t = [Link];
// left right case
[Link] = p;
[Link] =
leftRotate([Link]); [Link] = t;

return rightRotate(node); [Link] =

[Link](height([Link]),
}
height([Link]) + 1);
}
[Link] =
if (height([Link]) - [Link](height([Link]),
height([Link]) < -1) { height([Link]) + 1);
// right heavy return c;
}
 public Node leftRotate(Node c) { if (start >= end) {
Node p = [Link]; return;
Node t = [Link]; }
[Link] = c; int mid = (start + end) / 2;
[Link] = t; [Link](nums[mid]);
[Link] = populatedSorted(nums, start,
[Link](height([Link]), mid);
height([Link]) + 1);
populatedSorted(nums, mid + 1,
[Link] = end);
[Link](height([Link]),
}
height([Link]) + 1);
public void display() {
return p;
display([Link], "Root Node: ");
}
}
public void populate(int[] nums) {
private void display(Node node,
for (int i = 0; i < [Link]; i++)
String details) {
{
if (node == null) {
[Link](nums[i]);
return;
}
}
}
[Link](details +
[Link]);
public void populatedSorted(int[]
display([Link], "Left child of " +
nums) {
[Link] + " : ");
populatedSorted(nums, 0,
display([Link], "Right child of
[Link]);
" + [Link] + " : ");
}
}
private void populatedSorted(int[]
public boolean isEmpty() {
nums, int start, int end) {
return root == null;
 } }
public boolean balanced() { }
return balanced(root); Node root;
} public SegmentTree(int[] arr) {
private boolean balanced(Node // create a tree using this array
node) {
[Link] = constructTree(arr, 0,
if (node == null) { [Link] - 1);
return true; }
} private Node constructTree(int[]
arr, int start, int end) {
return [Link](height([Link])
- height([Link])) <= 1 && if(start == end) {
balanced([Link]) &&
// leaf node
balanced([Link]);
Node leaf = new Node(start,
}
end);
}
[Link] = arr[start];
SEGMENT TREES : return leaf;
class SegmentTree { }
private static class Node { // create new node with index
int data; you are at

int startInterval; Node node = new Node(start,

end);
int endInterval;
int mid = (start + end) / 2;
Node left;
[Link] = [Link](arr,
Node right;
start, mid);
public Node (int startInterval, int
[Link] =
endInterval) {
[Link](arr, mid + 1, end);
[Link] = startInterval;
[Link] = endInterval;
 [Link] = [Link] + [Link](str + '\n');
[Link];
// call recursion
return node;
if([Link] != null) {
}
display([Link]); }
public void display() {
if([Link] != null) {
display([Link]);
display([Link]) }}
}
// query
private void display(Node node) {
public int query(int qsi, int qei) {
String str = "";
return [Link]([Link], qsi,
if([Link] != null) { qei); }
str = str + "Interval=[" + private int query(Node node, int
[Link] + "-" + qsi, int qei) {
[Link] + "] and data:
if([Link] >= qsi &&
" + [Link] + " => ";
[Link] <= qei) {
} else {
// node is completely lying inside
str = str + "No left child"; } query
// for current node return [Link];
str = str + "Interval=[" + } else if ([Link] > qei
[Link] + "-" + || [Link] < qsi) {
[Link] + "] and data: " +
// completely outside
[Link] + " <= ";
return 0;
if([Link] != null) {
} else {
str = str + "Interval=[" +
[Link] + "-" + return [Link]([Link], qsi,
[Link] + "] and data: qei) + [Link]([Link], qsi,
" + [Link]; qei); } }

} else { // update

str = str + "No right child"; }

 public void update(int index, int
value) {
[Link] = update([Link],
index, value); }
private int update(Node node, int
index, int value) {
if (index >= [Link]&&
index <= [Link]){
if(index == [Link] &&
index == [Link]) {
[Link] = value;
return [Link];
} else {
int leftAns = update([Link],
index, value);
int rightAns =
update([Link], index, value);
[Link] = leftAns + rightAns;
return [Link];
}
}
return [Link];
}
}