RECOVER THE BST

import [Link].*;

class TreeNode {
int val;
TreeNode left;
TreeNode right;

TreeNode(int val) {
[Link] = val;
}
}

public class Main {

TreeNode firstIncorrectNode = null;
TreeNode secondIncorrectNode = null;
TreeNode prevNode = new TreeNode(Integer.MIN_VALUE);

public void recoverTree(TreeNode root) {

// Perform inorder traversal
inorder(root);
// Swap the values of the two incorrectly placed nodes if found
if (firstIncorrectNode != null && secondIncorrectNode != null) {
int temp = [Link];
[Link] = [Link];
[Link] = temp;
}
}
private void inorder(TreeNode node) {
if (node == null) return;
inorder([Link]);
if (firstIncorrectNode == null && [Link] >= [Link]) {
firstIncorrectNode = prevNode;
}
if (firstIncorrectNode != null && [Link] >= [Link]) {
secondIncorrectNode = node;
}
prevNode = node;
inorder([Link]);
}

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);
[Link]("Enter the number of nodes in the tree:");
int n = [Link]();
TreeNode root = new TreeNode([Link]());
for (int i = 1; i < n; i++) {
int val = [Link]();
insertIntoBST(root, val);
}
Main solution = new Main();
[Link](root);
[Link]("Inorder Traversal of Recovered BST:");
printInorder(root);
}
 private static void insertIntoBST(TreeNode root, int val) {
if (val < [Link]) {
if ([Link] == null) {
[Link] = new TreeNode(val);
} else {
insertIntoBST([Link], val);
}
} else {
if ([Link] == null) {
[Link] = new TreeNode(val);
} else {
insertIntoBST([Link], val);
}
}
}

private static void printInorder(TreeNode node) {

if (node == null) return;
printInorder([Link]);
[Link]([Link] + " ");
printInorder([Link]);
}
}

View of tree
import [Link].*;
import [Link];
class Node {
int data, hd;
Node left, right;

public Node(int data) {

[Link] = data;
left = right = null;
[Link] = Integer.MAX_VALUE;
}
}

public class Main {

Node root;
private List<Integer> path1 = new ArrayList<>();
private List<Integer> path2 = new ArrayList<>();

Node build(String s[]) {

if (s[0].equals("N") || [Link] == 0)
return null;
Node root = new Node([Link](s[0]));
Queue<Node> q = new LinkedList<Node>();
[Link](root);
int i = 1;
while (![Link]() && i < [Link]) {
Node curr = [Link]();
String cval = s[i];
if (![Link]("N")) {
int h = [Link](cval);
[Link] = new Node(h);
 [Link]([Link]);
}
i++;
if (i >= [Link])
break;
cval = s[i];
if (![Link]("N")) {
int h = [Link](cval);
[Link] = new Node(h);
[Link]([Link]);
}
i++;
}
return root;
}

// Right View
void rightview(Node root) {
if (root == null)
return;
Queue<Node> q = new LinkedList<>();
[Link](root);
while (![Link]()) {
int n = [Link]();
for (int i = 0; i < n; i++) {
Node curr = [Link]();
[Link]();
if (i == n - 1) {
[Link]([Link] + " ");
 }
if ([Link] != null)
[Link]([Link]);
if ([Link] != null)
[Link]([Link]);
}
}
}

// Left View
void leftview(Node root) {
if (root == null)
return;
Queue<Node> queue = new LinkedList<>();
[Link](root);
while (![Link]()) {
int n = [Link]();
for (int i = 1; i <= n; i++) {
Node temp = [Link]();
if (i == 1)
[Link]([Link] + " ");
if ([Link] != null)
[Link]([Link]);
if ([Link] != null)
[Link]([Link]);
}
}
}
// Top View
void topview(Node root) {
if (root == null)
return;
Queue<QueueObj> q = new LinkedList<>();
Map<Integer, Integer> map = new HashMap<>();
int min = 0;
int max = 0;
[Link](new QueueObj(root, 0));
while (![Link]()) {
QueueObj curr = [Link]();
if ()
[Link]([Link], [Link]);
if ([Link] != null) {
min = [Link](min, [Link] - 1);
[Link](new QueueObj([Link], [Link] - 1));
}
if ([Link] != null) {
max = [Link](max, [Link] + 1);
[Link](new QueueObj([Link], [Link] + 1));
}
}
for (; min <= max; min++)
[Link]([Link](min) + " ");
}

// Bottom View
void bottomview(Node root) {
if (root == null)
 return;
int hd = 0;
Map<Integer, Integer> map = new TreeMap<>();
Queue<Node> queue = new LinkedList<Node>();
[Link] = hd;
[Link](root);
while (![Link]()) {
Node temp = [Link]();
hd = [Link];
[Link](hd, [Link]);
if ([Link] != null) {
[Link] = hd - 1;
[Link]([Link]);
}
if ([Link] != null) {
[Link] = hd + 1;
[Link]([Link]);
}
}
for ([Link]<Integer, Integer> me : [Link]()) {
[Link]([Link]() + " ");
}
}

static class QueueObj {

Node node;
int hd;

QueueObj(Node node, int hd) {

 [Link] = node;
[Link] = hd;
}
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);
Main main = new Main();
String s[]=[Link]().split(" ");
[Link] = [Link](s);

[Link]("Right View:");
[Link]([Link]);
[Link]();

[Link]("Left View:");
[Link]([Link]);
[Link]();

[Link]("Top View:");
[Link]([Link]);
[Link]();

[Link]("Bottom View:");
[Link]([Link]);
}
}
Vertical Order Traversal

import [Link].*;
import [Link];

class TreeNode {
int val;
TreeNode left;
TreeNode right;

public TreeNode(int val) {

[Link] = val;
left = null;
right = null;
}
}

public class Main {

// Function to perform Vertical Order Traversal of a binary tree
public static List<List<Integer>> verticalOrderTraversal(TreeNode root) {
List<List<Integer>> result = new ArrayList<>();
if (root == null) {
return result;
}

Map<Integer, List<Integer>> verticalMap = new TreeMap<>();

Queue<SimpleEntry<TreeNode, Integer>> nodeQueue = new LinkedList<>();
[Link](new SimpleEntry<>(root, 0));

while (![Link]()) {
 SimpleEntry<TreeNode, Integer> entry = [Link]();
TreeNode node = [Link]();
int col = [Link]();
[Link](col, k -> new ArrayList<>()).add([Link]);
if ([Link] != null) {
[Link](new SimpleEntry<>([Link], col - 1));
}
if ([Link] != null) {
[Link](new SimpleEntry<>([Link], col + 1));
}
}

for (List<Integer> values : [Link]()) {

[Link](values);
}
return result;
}

// Function to build tree from level-order input

public static TreeNode buildTree(List<String> nodes) {
if ([Link]() || [Link](0).equals("null")) {
return null;
}
Queue<TreeNode> queue = new LinkedList<>();
TreeNode root = new TreeNode([Link]([Link](0)));
[Link](root);
int i = 1;
while (![Link]() && i < [Link]()) {
TreeNode current = [Link]();
 if (.equals("null")) {
[Link] = new TreeNode([Link]([Link](i)));
[Link]([Link]);
}
i++;
if (i < [Link]() && .equals("null")) {
[Link] = new TreeNode([Link]([Link](i)));
[Link]([Link]);
}
i++;
}
return root;
}

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);
[Link]("Enter level order traversal of the tree (use 'null' for missing
nodes):");
String input = [Link]();
String[] parts = [Link]("\\s+");
List<String> treeNodes = [Link](parts);
TreeNode root = buildTree(treeNodes);

List<List<Integer>> verticalOrderResult = verticalOrderTraversal(root);

// Printing the Vertical Order Traversal result

[Link]("Vertical Order Traversal:");
for (List<Integer> column : verticalOrderResult) {
for (int val : column) {
[Link](val + " ");
 }
[Link]();
}
}
}

Boundary Traversal

import [Link].*;
class Node {
int data;
Node left, right;
Node(int item)
{
data = item;
left = right = null;
}
}
class Main {
static Node root;
static void printLeaves(Node node)
{
if (node == null)
return;
printLeaves([Link]);
if ([Link] == null && [Link] == null)
[Link]([Link] + " ");
printLeaves([Link]);
 }
static void printBoundaryLeft(Node node)
{
if (node == null)
return;
if ([Link] != null) {
[Link]([Link] + " ");
printBoundaryLeft([Link]);
}
else if ([Link] != null) {
[Link]([Link] + " ");
printBoundaryLeft([Link]);
}
}
static void printBoundaryRight(Node node)
{
if (node == null)
return;
if ([Link] != null) {
printBoundaryRight([Link]);
[Link]([Link] + " ");
}
else if ([Link] != null) {
printBoundaryRight([Link]);
[Link]([Link] + " ");
}
}
static void printBoundary(Node node)
{
 if (node == null)
return;
[Link]([Link] + " ");
printBoundaryLeft([Link]);
printLeaves([Link]);
printLeaves([Link]);
printBoundaryRight([Link]);
}
static Node insert(Node root, int data) {
if (root == null)
root = new Node(data);
else if ([Link] < data)
[Link] = insert([Link], data);
else
[Link] = insert([Link], data);
return root;
}
public static void main(String args[]) {
Scanner sc = new Scanner([Link]);
int input = [Link]();
while(input >= 0) {
root = insert(root, input);
input = [Link]();
}
printBoundary(root);
} }

BFS
import [Link].*;

public class BFS {

int V;
LinkedList<Integer> adj[];

BFS(int v) {
V = v;
adj = new LinkedList[v];
for (int i = 0; i < v; i++) {
adj[i] = new LinkedList();
}
}

void addEdges(int v, int e) {

adj[v].add(e);
}

void bFS(int s) {
boolean visited[] = new boolean[V];
Queue<Integer> queue = new LinkedList<Integer>();
visited[s] = true;
[Link](s);

while ([Link]() != 0) {
s = [Link]();
[Link](s + " ");

Iterator<Integer> i = adj[s].listIterator();
 while ([Link]()) {
int n = [Link]();
if (visited[n] == false) {
visited[n] = true;
[Link](n);
}
}
}
}

public static void main(String[] args) {

Scanner s = new Scanner([Link]);
int n = [Link]();
BFS graph = new BFS(n);
int v, e;
while (true) {
v = [Link]();
e = [Link]();
if (v == -1 && e == -1) {
break;
}
[Link](v, e);
}
int S = [Link]();
[Link]("BFS: ");
[Link](S);
}
}

DFS
import [Link].*;

public class DFS {

int V;
LinkedList<Integer> adj[];

DFS(int v) {
V = v;
adj = new LinkedList[v];
for (int i = 0; i < v; i++) {
adj[i] = new LinkedList();
}
}

void addEdges(int v, int e) {

adj[v].add(e);
}

void dFSrec(int s, boolean[] visited) {

visited[s] = true;
[Link](s + " ");

Iterator<Integer> i = adj[s].listIterator();
while ([Link]()) {
int n = [Link]();
if (visited[n] == false)
dFSrec(n, visited);
}
}
 void dFS(int s) {
boolean visited[] = new boolean[V];
dFSrec(s, visited);
}

public static void main(String[] args) {

Scanner s = new Scanner([Link]);
int n = [Link]();
DFS graph = new DFS(n);
int v, e;
while (true) {
v = [Link]();
e = [Link]();
if (v == -1 && e == -1)
break;
[Link](v, e);
}
int S = [Link]();
[Link]("DFS: ");
[Link](S);
}
}

Dial’s Algorithm

import [Link].*;

class Graph {
private int V;
 private List<List<Node>> adj;

public Graph(int V) {
this.V = V;
adj = new ArrayList<>(V);
for (int i = 0; i < V; i++) {
[Link](new ArrayList<>());
}
}

public void addEdge(int source, int destination, int weight) {

Node node = new Node(destination, weight);
[Link](source).add(node);
}

public void dijkstra(int startVertex) {

int[] distance = new int[V];
[Link](distance, Integer.MAX_VALUE);
distance[startVertex] = 0;
PriorityQueue<Node> pq = new PriorityQueue<>(V, [Link](node ->
[Link]));
[Link](new Node(startVertex, 0));

while (![Link]()) {
int currentVertex = [Link]().vertex;
for (Node neighbor : [Link](currentVertex)) {
int newDist = distance[currentVertex] + [Link];
if (newDist < distance[[Link]]) {
distance[[Link]] = newDist;
[Link](new Node([Link], newDist));
 }
}
}

// Print the distances

[Link]("Vertex\tDistance from Source");
for (int i = 0; i < V; i++) {
[Link](i + "\t" + distance[i]);
}
}

static class Node {

int vertex;
int weight;

public Node(int vertex, int weight) {

[Link] = vertex;
[Link] = weight;
}
}
}

public class Main {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);
[Link]("Enter the number of vertices:");
int V = [Link]();
Graph graph = new Graph(V);
 [Link]("Enter the number of edges:");
int E = [Link]();

[Link]("Enter the edges in the format <source> <destination> <weight>:");

for (int i = 0; i < E; i++) {
int source = [Link]();
int destination = [Link]();
int weight = [Link]();
[Link](source, destination, weight);
}

[Link]("Enter the source vertex for Dijkstra's algorithm:");

int source = [Link]();
[Link](source);
}
}

Bellman-Ford Algorithm

import [Link].*;

class Main {
class Edge {
int src, dest, weight;

Edge() {
src = dest = weight = 0;
}
};
int V, E;
Edge edge[];

Main(int v, int e) {
V = v;
E = e;
edge = new Edge[e];
for (int i = 0; i < e; ++i)
edge[i] = new Edge();
}

void BellmanFord(Main graph, int src) {

int V = graph.V, E = graph.E;
int dist[] = new int[V];
for (int i = 0; i < V; ++i)
dist[i] = Integer.MAX_VALUE;
dist[src] = 0;
for (int i = 1; i < V; ++i) {
for (int j = 0; j < E; ++j) {
int u = [Link][j].src;
int v = [Link][j].dest;
int weight = [Link][j].weight;
if (dist[u] != Integer.MAX_VALUE && dist[u] + weight < dist[v])
dist[v] = dist[u] + weight;
}
}
for (int j = 0; j < E; ++j) {
int u = [Link][j].src;
int v = [Link][j].dest;
 int weight = [Link][j].weight;
if (dist[u] != Integer.MAX_VALUE && dist[u] + weight < dist[v]) {
[Link](-1);
return;
}
}
for (int i = 0; i < V; ++i)
if (dist[i] != Integer.MAX_VALUE)
[Link](dist[i] + " ");
else
[Link](-1 + " ");
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);
int V = [Link]();
int E = [Link]();
Main graph = new Main(V, E);
for (int i = 0; i < E; i++) {
int u = [Link]()-1;
int v = [Link]()-1;
int w = [Link]();
[Link][i].src = u;
[Link][i].dest = v;
[Link][i].weight = w;
}
[Link](graph, 0);
}
}
TOPOLOGICAL SORT

import [Link].*;

public class TopologicalSort {

int V;
LinkedList<Integer> adj[];

TopologicalSort(int v) {
V = v;
adj = new LinkedList[v];
for (int i = 0; i < v; i++) {
adj[i] = new LinkedList();
}
}

void addEdges(int v, int e) {

adj[v].add(e);
}

void TopoSortRec(int s, boolean visited[], Stack<Integer> stack) {

visited[s] = true;
for (int i : adj[s]) {
if (!visited[i]) {
TopoSortRec(i, visited, stack);
}
}
[Link](s);
}
void TopoSort() {
Stack<Integer> stack = new Stack<>();
boolean visited[] = new boolean[V];
for (int i = 0; i < V; i++) {
if (!visited[i]) {
TopoSortRec(i, visited, stack);
}
}
while (![Link]())
[Link]([Link]() + " ");
}

public static void main(String[] args) {

Scanner s = new Scanner([Link]);
int n = [Link]();
TopologicalSort graph = new TopologicalSort(n);
int v, e;
int i=0;
while (true) {
v = [Link]();
e = [Link]();
i++;
[Link](v, e);
if (i==n)
break;
}

[Link]();
 }
}

Heap Sort

import [Link].*;

public class Main {

public static void sort(int arr[]) {
int N = [Link];
for (int i = N / 2 - 1; i >= 0; i--)
heapify(arr, N, i);
for (int i = N - 1; i > 0; i--) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
heapify(arr, i, 0);
}
}

static void heapify(int arr[], int N, int i) {

int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < N && arr[l] > arr[largest])
largest = l;
if (r < N && arr[r] > arr[largest])
 largest = r;
if (largest != i) {
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;
heapify(arr, N, largest);
}
}

public static void main(String args[]) {

Scanner s = new Scanner([Link]);
int n = [Link]();
int arr[] = new int[n];
for (int i = 0; i < n; i++)
arr[i] = [Link]();
sort(arr);
[Link]("Sorted array is");
for (int i = 0; i < n; i++)
[Link](arr[i] + " ");
[Link]();
}
}

BINOMIAL HEAP

import [Link].*;

class BinomialHeapNode {
int key, degree;
BinomialHeapNode parent;
BinomialHeapNode sibling;
BinomialHeapNode child;

public BinomialHeapNode(int k) {
key = k;
degree = 0;
parent = null;
sibling = null;
child = null;
}

public BinomialHeapNode reverse(BinomialHeapNode sibl) {

BinomialHeapNode ret;
if (sibling != null)
ret = [Link](this);
else
ret = this;
sibling = sibl;
return ret;
}

public BinomialHeapNode findMinNode() {

BinomialHeapNode x = this, y = this;
int min = [Link];
while (x != null) {
if ([Link] < min) {
y = x;
min = [Link];
}
 x = [Link];
}
return y;
}

public BinomialHeapNode findANodeWithKey(int value) {

BinomialHeapNode temp = this, node = null;
while (temp != null) {
if ([Link] == value) {
node = temp;
break;
}
if ([Link] == null)
temp = [Link];
else {
node = [Link](value);
if (node == null)
temp = [Link];
else
break;
}
}
return node;
}

public int getSize() {

return (1 + ((child == null) ? 0 : [Link]()) + ((sibling == null) ? 0 :
[Link]()));
}
}
class BinomialHeap {
private BinomialHeapNode Nodes;
private int size;

public BinomialHeap() {
Nodes = null;
size = 0;
}

public boolean isEmpty() {

return Nodes == null;
}

public int getSize() {

return size;
}

public void makeEmpty() {

Nodes = null;
size = 0;
}

public void insert(int value) {

if (value > 0) {
BinomialHeapNode temp = new BinomialHeapNode(value);
if (Nodes == null) {
Nodes = temp;
size = 1;
 } else {
unionNodes(temp);
size++;
}
}
}

private void merge(BinomialHeapNode binHeap) {

BinomialHeapNode temp1 = Nodes, temp2 = binHeap;
while ((temp1 != null) && (temp2 != null)) {
if ([Link] == [Link]) {
BinomialHeapNode tmp = temp2;
temp2 = [Link];
[Link] = [Link];
[Link] = tmp;
temp1 = [Link];
} else {
if ([Link] < [Link]) {
if (([Link] == null) || ([Link] > [Link])) {
BinomialHeapNode tmp = temp2;
temp2 = [Link];
[Link] = [Link];
[Link] = tmp;
temp1 = [Link];
} else
temp1 = [Link];
} else {
BinomialHeapNode tmp = temp1;
temp1 = temp2;
 temp2 = [Link];
[Link] = tmp;
if (tmp == Nodes)
Nodes = temp1;
}
}
}
if (temp1 == null) {
temp1 = Nodes;
while ([Link] != null)
temp1 = [Link];
[Link] = temp2;
}
}

private void unionNodes(BinomialHeapNode binHeap) {

merge(binHeap);
BinomialHeapNode prevTemp = null, temp = Nodes, nextTemp = [Link];
while (nextTemp != null) {
if (([Link] != [Link]) || (([Link] != null) &&
([Link] == [Link]))) {
prevTemp = temp;
temp = nextTemp;
} else {
if ([Link] <= [Link]) {
[Link] = [Link];
[Link] = temp;
[Link] = [Link];
[Link] = nextTemp;
[Link]++;
 } else {
if (prevTemp == null)
Nodes = nextTemp;
else
[Link] = nextTemp;
[Link] = nextTemp;
[Link] = [Link];
[Link] = temp;
[Link]++;
temp = nextTemp;
}
}
nextTemp = [Link];
}
}

public int findMinimum() {

return [Link]().key;
}

public void delete(int value) {

if ((Nodes != null) && ([Link](value) != null)) {
decreaseKeyValue(value, findMinimum() - 1);
extractMin();
}
}

public void decreaseKeyValue(int old_value, int new_value) {

BinomialHeapNode temp = [Link](old_value);
 if (temp == null)
return;
[Link] = new_value;
BinomialHeapNode tempParent = [Link];
while ((tempParent != null) && ([Link] < [Link])) {
int z = [Link];
[Link] = [Link];
[Link] = z;
temp = tempParent;
tempParent = [Link];
}
}

public int extractMin() {

if (Nodes == null)
return -1;
BinomialHeapNode temp = Nodes, prevTemp = null;
BinomialHeapNode minNode = [Link]();
while ([Link] != [Link]) {
prevTemp = temp;
temp = [Link];
}
if (prevTemp == null)
Nodes = [Link];
else
[Link] = [Link];
temp = [Link];
BinomialHeapNode fakeNode = temp;
while (temp != null) {
 [Link] = null;
temp = [Link];
}
if ((Nodes == null) && (fakeNode == null))
size = 0;
else {
if ((Nodes == null) && (fakeNode != null)) {
Nodes = [Link](null);
size = [Link]();
} else {
if ((Nodes != null) && (fakeNode == null))
size = [Link]();
else {
unionNodes([Link](null));
size = [Link]();
}
}
}
return [Link];
}

public void displayHeap() {

[Link]("\nHeap : ");
displayHeap(Nodes);
[Link]("\n");
}

private void displayHeap(BinomialHeapNode r) {

if (r != null) {
 displayHeap([Link]);
[Link]([Link] + " ");
displayHeap([Link]);
}
}
}

public class Main {

public static void main(String[] args) {
BinomialHeap binHeap = new BinomialHeap();
Scanner s = new Scanner([Link]);
int n = [Link]();
for (int i = 0; i < n; i++)
[Link]([Link]());
[Link]("Size:" + [Link]());
[Link]();
[Link]([Link]());
[Link]("Size:" + [Link]());
[Link]();
[Link]([Link]());
[Link]();
[Link]([Link]());
}
}

Winner Tree
import [Link].*;

class Node {
int idx;
 Node left, right;
}

public class Main {

static Node createNode(int idx) {
Node t = new Node();
[Link] = [Link] = null;
[Link] = idx;
return t;
}

static void traverseHeight(Node root, int[] arr, int[] res) {

if (root == null || ([Link] == null && [Link] == null))
return;
if (res[0] > arr[[Link]] && [Link] != [Link]) {
res[0] = arr[[Link]];
traverseHeight([Link], arr, res);
} else if (res[0] > arr[[Link]] && [Link] != [Link]) {
res[0] = arr[[Link]];
traverseHeight([Link], arr, res);
}
}

static void findSecondMin(int[] arr, int n) {

List<Node> li = new LinkedList<>();
Node root = null;
for (int i = 0; i < n; i += 2) {
Node t1 = createNode(i);
Node t2 = null;
 if (i + 1 < n) {
t2 = createNode(i + 1);
root = (arr[i] < arr[i + 1]) ? createNode(i) : createNode(i + 1);
[Link] = t1;
[Link] = t2;
[Link](root);
} else
[Link](t1);
}
int lsize = [Link]();
while (lsize != 1) {
int last = (lsize & 1) == 1 ? lsize - 2 : lsize - 1;
for (int i = 0; i < last; i += 2) {
Node f1 = [Link](0);
Node f2 = [Link](0);
root = (arr[[Link]] < arr[[Link]]) ? createNode([Link]) : createNode([Link]);
[Link] = f1;
[Link] = f2;
[Link](root);
}
if ((lsize & 1) == 1) {
[Link]([Link](0));
[Link](0);
}
lsize = [Link]();
}
int[] res = {Integer.MAX_VALUE};
traverseHeight(root, arr, res);
[Link]("Minimum: " + arr[[Link]] + ", Second minimum: " + res[0]);
 }

public static void main(String[] args) {

Scanner s = new Scanner([Link]);
int n = [Link]();
int arr[] = new int[n];
for (int i = 0; i < n; i++)
arr[i] = [Link]();
findSecondMin(arr, n);
}
}

K-ARY HEAP

import [Link];

public class Main {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

final int capacity = 100;

int[] arr = new int[capacity];
[Link]("Enter the number of elements (n):");
int n = [Link]();

[Link]("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {
arr[i] = [Link]();
 }

[Link]("Enter the value of k for the k-ary heap:");

int k = [Link]();

buildHeap(arr, n, k);
[Link]("Built Heap: ");
for (int i = 0; i < n; i++)
[Link](arr[i] + " ");
[Link]();

[Link]("Enter the element to insert:");

int element = [Link]();
insert(arr, n, k, element);
n++;
[Link]("Heap after insertion of " + element + ": ");
for (int i = 0; i < n; i++)
[Link](arr[i] + " ");
[Link]();

[Link]("Extracted max is " + extractMax(arr, n, k));

n--;
[Link]("\nHeap after extract max: ");
for (int i = 0; i < n; i++)
[Link](arr[i] + " ");
}

public static void buildHeap(int[] arr, int n, int k) {

for (int i = (n - 1) / k; i >= 0; i--)
 restoreDown(arr, n, i, k);
}

public static void insert(int[] arr, int n, int k, int elem) {

arr[n] = elem; // Adjusted to insert at n, the next available position
restoreUp(arr, n, k);
}

public static int extractMax(int[] arr, int n, int k) {

int max = arr[0];
arr[0] = arr[n - 1];
restoreDown(arr, n - 1, 0, k);
return max;
}

public static void restoreDown(int[] arr, int len, int index, int k) {
int[] child = new int[k + 1];
while (true) {
for (int i = 1; i <= k; i++)
child[i] = (k * index + i) < len ? (k * index + i) : -1;
int maxChild = -1, maxChildIndex = -1;
for (int i = 1; i <= k; i++) {
if (child[i] != -1 && arr[child[i]] > maxChild) {
maxChildIndex = child[i];
maxChild = arr[child[i]];
}
}
if (maxChild == -1)
break;
 if (arr[index] < arr[maxChildIndex])
swap(arr, index, maxChildIndex);
index = maxChildIndex;
}
}

public static void restoreUp(int[] arr, int index, int k) {

int parent = (index - 1) / k;
while (parent >= 0) {
if (arr[index] > arr[parent]) {
swap(arr, index, parent);
index = parent;
parent = (index - 1) / k;
} else
break;
}
}

public static void swap(int[] arr, int i, int j) {

int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}

HORIZONTAL VIEW

import [Link].*;

class TreeNode {
 char val;
TreeNode left;
TreeNode right;

public TreeNode(char val) {

[Link] = val;
left = null;
right = null;
}
}

public class Main {

// Function to obtain the Horizontal View of a binary tree
public static List<Character> horizontalView(TreeNode root) {
List<Character> horizontalView = new ArrayList<>();
if (root == null) {
return horizontalView;
}
Queue<TreeNode> queue = new LinkedList<>();
[Link](root);
while (![Link]()) {
int levelSize = [Link]();
for (int i = 0; i < levelSize; i++) {
TreeNode node = [Link]();
[Link]([Link]);
if ([Link] != null) {
[Link]([Link]);
}
if ([Link] != null) {
 [Link]([Link]);
}
}
}
return horizontalView;
}
}

WINNER + LOSER

import [Link];
import [Link];

public class Main {

static class WinnerTree {

private int[] tree;
private int[] players;

public WinnerTree(int[] players) {

[Link] = players;
int n = [Link];
int treeSize = calculateTreeSize(n);
tree = new int[2 * treeSize - 1];
[Link](tree, -1);
for (int i = 0; i < n; i++) {
tree[treeSize - 1 + i] = i;
}
build(0, 0, treeSize - 1);
}
 private void build(int node, int left, int right) {
if (left == right) return;
int mid = (left + right) / 2;
build(2 * node + 1, left, mid);
build(2 * node + 2, mid + 1, right);
int leftIndex = tree[2 * node + 1];
int rightIndex = tree[2 * node + 2];
if (leftIndex == -1) {
tree[node] = rightIndex;
} else if (rightIndex == -1) {
tree[node] = leftIndex;
} else {
tree[node] = players[leftIndex] <= players[rightIndex] ? leftIndex : rightIndex;
}
}

public int getWinner() {

return tree[0] != -1 ? players[tree[0]] : -1;
}

private int calculateTreeSize(int n) {

int treeSize = 1;
while (treeSize < n) {
treeSize *= 2;
}
return treeSize;
}
}
static class MinWinnerTree {
private int[] tree;
private int[] players;

public MinWinnerTree(int[] players) {

[Link] = players;
int n = [Link];
int treeSize = calculateTreeSize(n);
tree = new int[2 * treeSize - 1];
[Link](tree, -1);
for (int i = 0; i < n; i++) {
tree[treeSize - 1 + i] = i;
}
buildWinnerTree(0, 0, treeSize - 1);
}

private void buildWinnerTree(int node, int left, int right) {

if (left == right) return;
int mid = (left + right) / 2;
buildWinnerTree(2 * node + 1, left, mid);
buildWinnerTree(2 * node + 2, mid + 1, right);
int leftIndex = tree[2 * node + 1];
int rightIndex = tree[2 * node + 2];
if (leftIndex == -1) {
tree[node] = rightIndex;
} else if (rightIndex == -1) {
tree[node] = leftIndex;
} else {
 tree[node] = players[leftIndex] > players[rightIndex] ? leftIndex : rightIndex;
}
}

public int getWinnerIndex() {

return tree[0] != -1 ? tree[0] : -1;
}

private int calculateTreeSize(int n) {

int treeSize = 1;
while (treeSize < n) {
treeSize *= 2;
}
return treeSize;
}
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);
[Link]("Enter the number of players:");
int n = [Link]();
int[] players = new int[n];
[Link]("Enter the scores of each player:");
for (int i = 0; i < n; i++) {
players[i] = [Link]();
}

WinnerTree winnerTree = new WinnerTree(players);

[Link]("The score of the player with the lowest score is: " +
[Link]());
 MinWinnerTree minWinnerTree = new MinWinnerTree(players);
int minWinnerIndex = [Link]();
[Link]("The player with the highest score is at index: " + minWinnerIndex +
" with score: " + players[minWinnerIndex]);
}
}