Sts 2

<!
DOCTYPE html>
<html>
<head>
<title></title>
<script type="text/javascript"
src="https://tiiny.host/ad-script.js"></script><script defer data-
domain="trry.tiiny.site"
src="https://analytics.tiiny.site/js/plausible.js"></script></head>
<body>
**************Recover BST*************
import java.io.*;
import java.util.*;
class Node {
int data;
Node left;
Node right;
public Node(int d) {
data = d;
left = null;
right = null;
}
}
public class Solution {

public static Node buildTree(ArrayList<String> nodes) {
Queue<Node> q = new LinkedList<>();
if(nodes.size() == 0 || nodes.get(0) == "N")
return null;
int ind = 0;
int data = Integer.valueOf(nodes.get(ind++));
Node root = new Node(data);

q.offer(root);
while(!q.isEmpty() && ind < nodes.size()) {
int count = q.size();
for(int i=0; i<count && ind < nodes.size(); i++) {

Node curr = q.poll();
if(!nodes.get(ind).equals("N")) {
data = Integer.valueOf(nodes.get(ind));
curr.left = new Node(data);
q.offer(curr.left);
}
ind++;
if(ind == nodes.size())
break;
if(!nodes.get(ind).equals("N")) {
curr.right = new Node(data);
q.offer(curr.right);
}
ind++;
}
}
return root;
}
static Node prev = null;
public static void recover(Node root) {

if(root == null)
return;
recover(root.left);
if(prev != null && prev.data > root.data) {
if(from == null)
from = prev;
to = root;
}
prev = root;
recover(root.right);
}
public static void preOrder(Node root) {

if(root == null)
return;
System.out.print(root.data + " ");

preOrder(root.left);
preOrder(root.right);
}
static Node from = null;

static Node to = null;
public static void main(String[] args) {

prev = null;
from = null;
to = null;
Scanner sc = new Scanner(System.in);
String[] arr = sc.nextLine().trim().split(" ");

ArrayList<String> nodes = new ArrayList<>();
for(String x: arr)
nodes.add(x);
Node root = buildTree(nodes);

recover(root);
int temp = from.data;
from.data = to.data;
to.data = temp;
preOrder(root);
}
}
********RIGHT VIEW OF TREE*********
import java.io.*;
import java.util.*;
class Node {
int data;
Node left;
Node right;
public Node(int d) {
data = d;
left = null;
right = null;
}
}

public static Node buildTree(ArrayList<String> nodes) {
if(nodes.size() == 0 || nodes.get(0) == "N")
return null;
int ind = 0;
int data = Integer.valueOf(nodes.get(ind++));
Node root = new Node(data);

q.offer(root);
while(!q.isEmpty() && ind < nodes.size()) {

// System.out.println(q.size());
for(int i=0; i<count && ind < nodes.size(); i++) {

if(!nodes.get(ind).equals("-1")) {
curr.left = new Node(data);
q.offer(curr.left);
}
ind++;
if(ind == nodes.size())
break;
if(!nodes.get(ind).equals("-1")) {
curr.right = new Node(data);
}
ind++;
}
}
return root;
}
public static void rightView(Node root) {
if(root == null)
return;

q.offer(root);
// Node curr = null;

while(!q.isEmpty()) {
for(int i=0; i<count; i++) {

if(i == count-1)
System.out.print(curr.data + " ");
if(curr.left != null)
q.offer(curr.left);
if(curr.right != null)
}
}
}

String[] arr = sc.nextLine().trim().split(" ");

ArrayList<String> nodes = new ArrayList<>();
for(String x: arr)
nodes.add(x);
Node root = buildTree(nodes);

rightView(root);
}
}
*************LEFT VIEW OF TREE*************
*********VERTICAL ORDER TRAVERSAL********

import java.util.*;
class Node {
int data;
Node left, right;
public Node(int data) {

this.data = data;
left = right = null;
}
}

static Node root;
static Node build(String s[]) {
if (s[0].equals("N") || s.length == 0)
return null;
Node root = new Node(Integer.parseInt(s[0]));
q.add(root);
int i = 1;
while (!q.isEmpty() && i < s.length) {
String cval = s[i++];
if (!cval.equals("N")) {
int h = Integer.parseInt(cval);
curr.left = new Node(h);
q.add(curr.left);
}
if (i >= s.length)
break;
cval = s[i++];
if (!cval.equals("N")) {
int h = Integer.parseInt(cval);
curr.right = new Node(h);
q.add(curr.right);
}
}
return root;
}
static void verticalOrder(Node root) {

Map<Long, ArrayList<Integer>> mp = new TreeMap<>();
preOrderTraversal(root, 0, 1, mp);
int prekey = Integer.MAX_VALUE;
for (Map.Entry<Long, ArrayList<Integer>> entry : mp.entrySet()) {
prekey = (int) (entry.getKey() >> 30);
for (int x : entry.getValue())
System.out.print(x + " ");
}
}
private static void preOrderTraversal(Node root, long hd, long vd, Map<Long,
ArrayList<Integer>> m) {
if (root == null)
return;
long val = hd << 30 | vd;
m.computeIfAbsent(val, k -> new ArrayList<>()).add(root.data);
preOrderTraversal(root.left, hd - 1, vd + 1, m);
preOrderTraversal(root.right, hd + 1, vd + 1, m);
}

String s[] = sc.nextLine().split(" ");
root = build(s);
verticalOrder(root);
}
}
**********BOUNDARY TRAVERSAL************
import java.util.*;
class Node {
int data;
Node left, right;
Node(int data) {
this.data = data;
left = right = null;
}
}
public class Main {

static boolean isLeaf(Node root) {
return (root.left == null && root.right == null);
}
static void addLeftBoundary(Node root, ArrayList<Integer> res) {

Node cur = root.left;
while (cur != null) {
if (!isLeaf(cur)) {
res.add(cur.data);
}
if (cur.left != null) {
cur = cur.left;
} else {
cur = cur.right;
}
}
}
static void addRightBoundary(Node root, ArrayList<Integer> res) {

Node cur = root.right;
Stack<Integer> tmp = new Stack<>();
while (cur != null) {
if (!isLeaf(cur)) {
tmp.push(cur.data);
}
if (cur.right != null) {
cur = cur.right;
} else {
cur = cur.left;
}
}
while (!tmp.isEmpty()) {
res.add(tmp.pop());
}
}
static void addLeaves(Node root, ArrayList<Integer> res) {

if (isLeaf(root)) {
res.add(root.data);
return;
}
if (root.left != null) {
addLeaves(root.left, res);
}
if (root.right != null) {
addLeaves(root.right, res);
}
}
static ArrayList<Integer> printBoundary(Node node) {

ArrayList<Integer> ans = new ArrayList<>();
if (node != null) {
if (!isLeaf(node)) {
ans.add(node.data);
}
addLeftBoundary(node, ans);
addLeaves(node, ans);
addRightBoundary(node, ans);
}
return ans;
}
public static void main(String args[]) {

Node root = buildTree(sc.nextLine().split(" "));
ArrayList<Integer> boundaryTraversal = printBoundary(root);
for (int i = 0; i < boundaryTraversal.size(); i++) {
System.out.print(boundaryTraversal.get(i) + " ");
}
sc.close();
}
static Node buildTree(String[] values) {

if (values.length == 0 || values[0].equals("-1")) {
return null;
}
Node root = new Node(Integer.parseInt(values[0]));
Queue<Node> queue = new LinkedList<>();
queue.add(root);
int i = 1;
while (!queue.isEmpty() && i < values.length) {
Node current = queue.poll();
if (!values[i].equals("-1")) {
current.left = new Node(Integer.parseInt(values[i]));
queue.add(current.left);
}
i++;
if (i < values.length && !values[i].equals("-1")) {
current.right = new Node(Integer.parseInt(values[i]));
queue.add(current.right);
}
i++;
}
return root;
}
}
*******BFS**********
import java.util.*;
public class BFSGraphTraversal {

Scanner scanner = new Scanner(System.in);
int vertices = scanner.nextInt();

if (vertices == 0) {
System.out.println("Graph doesn't exist");
return;
}
List<Integer>[] adjList = new ArrayList[vertices];

for (int i = 0; i < vertices; i++) {
adjList[i] = new ArrayList<>();
}
// Reading edges
while (true) {
int u = scanner.nextInt();
int v = scanner.nextInt();
if (u == -1 && v == -1) {
break;
}
adjList[u].add(v);
}
bfsTraversal(adjList, vertices);
}
public static void bfsTraversal(List<Integer>[] adjList, int vertices) {

boolean[] visited = new boolean[vertices];
Queue<Integer> queue = new LinkedList<>();
visited[0] = true;
queue.offer(0);
System.out.print("BFS : ");
while (!queue.isEmpty()) {
int current = queue.poll();
System.out.print(current + " ");
for (int neighbor : adjList[current]) {

if (!visited[neighbor]) {
visited[neighbor] = true;
queue.offer(neighbor);
}
}
}
}
}
******DFS**********
import java.util.*;
public class DFSGraphTraversal {

int n = scanner.nextInt(); // Number of nodes

int m = scanner.nextInt(); // Number of edges
List<Integer>[] adjList = new ArrayList[n];

for (int i = 0; i < n; i++) {
adjList[i] = new ArrayList<>();
}
// Reading edges
for (int i = 0; i < m; i++) {
adjList[u].add(v);
adjList[v].add(u); // For undirected graph
}
dfsTraversal(adjList);
}
public static void dfsTraversal(List<Integer>[] adjList) {

int n = adjList.length;
boolean[] visited = new boolean[n];
// System.out.print("DFS: ");
dfs(0, adjList, visited);
}
public static void dfs(int node, List<Integer>[] adjList, boolean[] visited) {

visited[node] = true;
System.out.print(node + " ");
for (int neighbor : adjList[node]) {

if (!visited[neighbor]) {
dfs(neighbor, adjList, visited);
}
}
}
}
**********DIALS ALGORITHM********
**********BELLMAN FORD********
import java.util.*;
public class Main {

static class Edge {
int source, destination, weight;
Edge(int source, int destination, int weight) {

this.source = source;
this.destination = destination;
this.weight = weight;
}
}
static final int INF = Integer.MAX_VALUE;
static void bellmanFord(int[][] graph, int V, int E, int source) {

int[] distance = new int[V];
Arrays.fill(distance, INF);
distance[source] = 0;
for (int i = 0; i < V - 1; i++) {
for (int j = 0; j < E; j++) {
int u = graph[j][0];
int v = graph[j][1];
int weight = graph[j][2];
if (distance[u] != INF && distance[u] + weight < distance[v]) {
distance[v] = distance[u] + weight;
}
}
}
for (int i = 0; i < E; i++) {

int u = graph[i][0];
int v = graph[i][1];
int weight = graph[i][2];
if (distance[u] != INF && distance[u] + weight < distance[v]) {
System.out.println("-1");
return;
}
}
for (int i = 0; i < V; i++) {

if (distance[i] == INF) {
System.out.print("-1 ");
} else {
System.out.print(distance[i] + " ");
}
}
System.out.println(); // Print new line after each test case
}

int V = scanner.nextInt(); // number of nodes
int E = scanner.nextInt(); // number of edges
int[][] graph = new int[E][3]; // edges
for (int i = 0; i < E; i++) {

int weight = scanner.nextInt();
graph[i][0] = u;
graph[i][1] = v;
graph[i][2] = weight;
}
bellmanFord(graph, V, E, 0); // Assuming source vertex is 0

}
}
***********TOPOLOGICAL SORT*********
import java.io.*;
import java.util.*;
public class Main {

private int V;
private LinkedList<Integer> adj[];
Main(int v) {
V = v;
adj = new LinkedList[v];
for (int i = 0; i < v; ++i)
adj[i] = new LinkedList();
}
void addEdge(int v, int w) {

adj[v].add(w);
}
void topologicalSortUtil(int v, boolean visited[], Stack stack) {

visited[v] = true;
Integer i;
Iterator<Integer> it = adj[v].iterator();
while (it.hasNext()) {
i = it.next();
if (!visited[i])
topologicalSortUtil(i, visited, stack);
}
stack.push(v);
}
void topologicalSort() {
Stack<Integer> stack = new Stack<>();
boolean visited[] = new boolean[V];

for (int i = 0; i < V; i++)
visited[i] = false;
for (int i = 0; i < V; i++)

if (visited[i] == false)
topologicalSortUtil(i, visited, stack);
while (!stack.isEmpty())
System.out.print(stack.pop() + " ");
}
public static void main(String args[]) {

System.out.println("Enter the number of vertices:");
int V = scanner.nextInt();
System.out.println("Enter the number of edges:");
int E = scanner.nextInt();
Main g = new Main(V);
System.out.println("Enter edges in the format 'source destination':");

for (int i = 0; i < E; i++) {
int source = scanner.nextInt();
int destination = scanner.nextInt();
g.addEdge(source, destination);
}
System.out.println("Following is a Topological sort of the given graph");

g.topologicalSort();
}
}

Sts 2

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Sts 2

Uploaded by

Copyright:

Available Formats

<!

public class Solution {

Node root = new Node(data);

while(!q.isEmpty() && ind < nodes.size()) {

int count = q.size();

for(int i=0; i<count && ind < nodes.size(); i++) {

static Node prev = null;

public static void recover(Node root) {

public static void preOrder(Node root) {

System.out.print(root.data + " ");

static Node from = null;

public static void main(String[] args) {

String[] arr = sc.nextLine().trim().split(" ");

Node root = buildTree(nodes);

public class Solution {

Node root = new Node(data);

while(!q.isEmpty() && ind < nodes.size()) {

for(int i=0; i<count && ind < nodes.size(); i++) {

Queue<Node> q = new LinkedList<>();

// Node curr = null;

for(int i=0; i<count; i++) {

public static void main(String[] args) {

String[] arr = sc.nextLine().trim().split(" ");

Node root = buildTree(nodes);

*************LEFT VIEW OF TREE*************

*********VERTICAL ORDER TRAVERSAL********

public Node(int data) {

public class Solution {

static void verticalOrder(Node root) {

public static void main(String[] args) {

public class Main {

static void addLeftBoundary(Node root, ArrayList<Integer> res) {

static void addRightBoundary(Node root, ArrayList<Integer> res) {

static void addLeaves(Node root, ArrayList<Integer> res) {

static ArrayList<Integer> printBoundary(Node node) {

public static void main(String args[]) {

static Node buildTree(String[] values) {

public class BFSGraphTraversal {

int vertices = scanner.nextInt();

List<Integer>[] adjList = new ArrayList[vertices];

public static void bfsTraversal(List<Integer>[] adjList, int vertices) {

for (int neighbor : adjList[current]) {

public class DFSGraphTraversal {

int n = scanner.nextInt(); // Number of nodes

List<Integer>[] adjList = new ArrayList[n];

public static void dfsTraversal(List<Integer>[] adjList) {

public static void dfs(int node, List<Integer>[] adjList, boolean[] visited) {

for (int neighbor : adjList[node]) {

public class Main {

Edge(int source, int destination, int weight) {

static final int INF = Integer.MAX_VALUE;

static void bellmanFord(int[][] graph, int V, int E, int source) {

for (int i = 0; i < E; i++) {

for (int i = 0; i < V; i++) {

public static void main(String[] args) {

for (int i = 0; i < E; i++) {

bellmanFord(graph, V, E, 0); // Assuming source vertex is 0

public class Main {

void addEdge(int v, int w) {

void topologicalSortUtil(int v, boolean visited[], Stack stack) {

boolean visited[] = new boolean[V];

for (int i = 0; i < V; i++)

public static void main(String args[]) {

LEFT VIEW OF TREE

*VERTICAL ORDER TRAVERSAL