Top infosys interview questions

public class LinkedList {
  public static Node reverse(Node head) {
    
    Node prev = null;
    Node current = head;
    Node next = null;
    while (current != null) {
      
      next = current.next;
      current.next = prev;
      prev = current;
      current = next;
    }
    return prev;
  }
}

class Node: def __init__(self, value): self.value = value self.left = None self.right = None def find_max(node): if node is None: return float('-inf') else: return max(node.value, find_max(node.left), find_max(node.right))

class Stack {
constructor() {

this.items = [] }
push(element) {

this.items.push(element) }
pop() {

return this.items.pop() }
peek() {

return this.items[this.items.length - 1] }
isEmpty() {

return this.items.length === 0 }
size() {

return this.items.length }
}

int find_min(int arr[], int n) {
  int min = arr[0];
  for (int i = 1;
  i < n;
  i++) {
    if (arr[i] < min) {
      min = arr[i];
    }
  }
  return min;
}

public class Queue {
  private Node front;
  private Node rear;
  public void enqueue(int data) {
    
    Node node = new Node(data);
    if (rear == null) {
      
      front = node;
      rear = node;
    }
    else {
      rear.next = node;
      rear = node;
    }
  }
  public int dequeue() {
    
    if (front == null) {
      
      return -1;
    }
    int data = front.data;
    front = front.next;
    if (front == null) {
      
      rear = null;
    }
    return data;
  }
}

def find_first_duplicate(arr): seen = set() for num in arr: if num in seen: return num seen.add(num) return None

function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;
  while (left <= right) {
    let mid = Math.floor((left + right) / 2);
    if (arr[mid] === target) {
      return mid;
    } else if (arr[mid] < target) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }
  return -1;
}

int maxSubArraySum(int arr[], int n) {
  int max_so_far = arr[0];
  int max_ending_here = arr[0];
  for (int i = 1;
  i < n;
  i++) {
    max_ending_here = max(arr[i], max_ending_here + arr[i]);
    max_so_far = max(max_so_far, max_ending_here);
  }
  return max_so_far;
}

public class MergeSort {
  public static void mergeSort(int[] arr) {
    
    if (arr.length <= 1) {
      
      return;
    }
    int mid = arr.length / 2;
    int[] left = new int[mid];
    int[] right = new int[arr.length - mid];
    System.arraycopy(arr, 0, left, 0, mid);
    System.arraycopy(arr, mid, right, 0, arr.length - mid);
    mergeSort(left);
    mergeSort(right);
    merge(left, right, arr);
  }
  public static void merge(int[] left, int[] right, int[] arr) {
    
    int i = 0;
    int j = 0;
    int k = 0;
    while (i < left.length && j < right.length) {
      
      if (left[i] <= right[j]) {
        
        arr[k] = left[i];
        i++;
      }
      else {
        arr[k] = right[j];
        j++;
      }
      k++;
    }
    while (i < left.length) {
      
      arr[k] = left[i];
      i++;
      k++;
    }
    while (j < right.length) {
      
      arr[k] = right[j];
      j++;
      k++;
    }
  }
}

def longest_common_prefix(strs): if not strs: return '' prefix = min(strs, key=len) for i, char in enumerate(prefix): for string in strs: if string[i] != char: return prefix[:i] return prefix

function dfs(graph, start) {
  let visited = new Set();
  let stack = [start];
  while (stack.length > 0) {
    let node = stack.pop();
    if (!visited.has(node)) {
      visited.add(node);
      console.log(node);
      for (let neighbor of graph[node]) {
        if (!visited.has(neighbor)) {
          stack.push(neighbor);
        }
      }
    }
  }
}