SDE - 1

// A simple inorder traversal based Java program
// to find k-th smallest element in a BST.

import java.io.*;
// A BST node
class Node {
int data;
Node left, right;
Node(int x)
{
data = x;
left = right = null;
}
}

class GFG {

static int count = 0;
// Recursive function to insert an key into BST
public static Node insert(Node root, int x)
{
if (root == null)
return new Node(x);
if (x < root.data)
root.left = insert(root.left, x);
else if (x > root.data)
root.right = insert(root.right, x);
return root;
}

// Function to find k'th largest element in BST
// Here count denotes the number of nodes processed so far
public static Node kthSmallest(Node root, int k)
{
// base case
if (root == null)
return null;

// search in left subtree
Node left = kthSmallest(root.left, k);

// if k'th smallest is found in left subtree, return it
if (left != null)
return left;

// if current element is k'th smallest, return it
count++;
if (count == k)
return root;

// else search in right subtree
return kthSmallest(root.right, k);
}

// Function to find k'th largest element in BST
public static void printKthSmallest(Node root, int k)
{
Node res = kthSmallest(root, k);
if (res == null)
System.out.println("There are less than k nodes in the BST");
else
System.out.println("K-th Smallest Element is " + res.data);
}

public static void main(String[] args)
{
Node root = null;
int keys[] = { 20, 8, 22, 4, 12, 10, 14 };
for (int x : keys)
root = insert(root, x);
int k = 3;
printKthSmallest(root, k);
}
}

// Java program to check if
// linked list is circular

import java.util.*;

class GFG {

/* Link list Node */
static class Node {
int data;
Node next;
}

/*This function returns true if given linked
list is circular, else false. */
static boolean isCircular(Node head)
{
// An empty linked list is circular
if (head == null)
return true;

// Next of head
Node node = head.next;

// This loop would stop in both cases (1) If
// Circular (2) Not circular
while (node != null && node != head)
node = node.next;

// If loop stopped because of circular
// condition
return (node == head);
}

// Utility function to create a new node.
static Node newNode(int data)
{
Node temp = new Node();
temp.data = data;
temp.next = null;
return temp;
}

/* Driver code*/
public static void main(String args[])
{
/* Start with the empty list */
Node head = newNode(1);
head.next = newNode(2);
head.next.next = newNode(3);
head.next.next.next = newNode(4);

System.out.print(isCircular(head) ? "Yes\n"
: "No\n");

// Making linked list circular
head.next.next.next.next = head;

System.out.print(isCircular(head) ? "Yes\n"
: "No\n");
}
}

Ans: Thread is a path of execution that is composed of a program counter, thread id, stack, and set of registers within the process. It is a basic unit of CPU utilization that makes communication more effective and efficient, enables utilization of multiprocessor architectures to a greater scale and greater efficiency, and reduces the time required in context switching. It simply provides a way to improve and increase the performance of applications through parallelism. Threads are sometimes called lightweight processes because they have their own stack but can access shared data.