Top 30 Java Programming interview questions

Last Updated on March 10, 2022 by Ria Pathak

Check if a given number is palindrome or not.
Ans. A palindrome is a number which is when reversed give the same number. We find the reverse and check whether it is equal to the given number or not.

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    String str = in.nextLine();
    int length = str.length();         
    boolean isPalindrome = true;          
    for(int i = 0; i < length; i++)
    {
        if(str.charAt(i) != str.charAt(length-1-i)) {
            System.out.println("Snot a palindrome.");
            isPalindrome = false;
            break;
        }
    }          
    if(isPalindrome) {
        System.out.println("palindrome.");
    }
}

Count the occurrence of a given character in string.
Ans.

public static void main(String args[]){
String str = "this is a string";
char ch = 's';
int count = 0;
for(char c:strArr){
  if(c == 's'){
    count++;
  }
}
  System.out.println(count);    
}

Find the GCD of two numbers in logn time.
Ans.

public static int gcd(int a, int b) {
while (((a > 0) && (b > 0))) {
  if ((a > b)) {
    a = (a % b);
  } else {
    b = (b % a);
  }
}
if ((a == 0)) {
  return b;
} else {
  return a;
}
}  
public static void main(String[] args) {
int a = new Scanner(System.in);
int b = new Scanner(System.in);
System.out.println(GCD.gcd(a, b));
}

Can you code the Binary Search Algorithm in Java?
Ans.

public int binarySearch(int a[], int num)
{
    if(num>a[a.length-1]||num<a[0])return -1;
    int start=0;
    int end =a.length-1;
    int mid=(start+end)/2;
    while(a[mid]!=num){
        if(num<mid){
            end=mid;
        }else{
            start=mid;
        }
        mid = (start+end)/2;
    }
    return mid;
}

Implement the merge Sort algorithm.
Ans. This is a Divide and conquer algorithm.


public static void main(String[] args) {
    int[] list = {4,5,2,1,3};
    mergeSort(list, 0, list.length - 1);
}
public static void mergeSort(int[] a, int first, int last)
  {
    if(last - first == 0) 
    {
    }
    else if (last - first == 1) 
    {
        if(a[first] > a[last])
        {
            int temp = a[first];
            a[first] = a[last];
            a[last] = temp;
        }
    }
    else    
    {
        int mid = (first + last) / 2;
        mergeSort(a, first, mid);
        mergeSort(a, mid + 1, last);
        merge(a, first, mid, last);
    }
  }
private static void merge(int[] a, int first, int mid, int last)
  {
    int[] temp = new int[last - first + 1];
    int i = first; int j = mid + 1;
    for(int k = first; k <= last; k++)
    {
        if(i > mid || j > last)
        {
            if(i > mid && j <= last)
            {
                System.out.println("a[j]: " + a[j]);
                temp[k - first] = a[j];
                j++;
            }
            else if(i <= mid && j > last)
            {
                System.out.println("a[i]: " + a[i]);
                temp[k - first] = a[i];
                i++;
            }
            else
            {
                break;
            }
        }
        else
        {
            if(a[i] < a[j])
            {
                temp[k - first] = a[i];
                i++;
            }
            else
            {
                temp[k - first] = a[j];
                j++;
            }
        }
    }
    for(int count = 0; count < temp.length; count++)
    {
        a[first + count] = temp[count];
    }
  }

Implement a quicksort algorithm.
Ans.

public int partition(ArrayList list, int start, int end)  {
double pivot = list.get(end);
int i = (start - 1); 
for (int j = start; j < end; j++) {
if (list.get(j) <= pivot) {  
    i++;
    double temp = list.get(i);
    list.set(i, list.get(j));
    list.set(j, temp);
    }
} double temp = list.get(i + 1); 
  list.set((i + 1), list.get(end));
  list.set(end, temp);
  return i + 1;
}
public ArrayList sort(ArrayList list, int start, int end) { 
if (start < end) {
int pi = partition(list, start, end); 
sort(list, start, pi - 1); 
sort(list, pi + 1, end);
    }  return list;
} 
public ArrayList Solve(double[] nums, int a, int b, int c) {
ArrayList newList = new ArrayList();
double xyz;
for (int i = 0; i < nums.length; i++) {
    xyz = ((a * nums[i]) * nums[i]) + b * nums[i] + c;
    newList.add(xyz);
    } return newList; 
} 
public static void main (String[] args) {
QuickSort obj = new QuickSort();
double nums[] = {1,2,4, 9,5,3,0};
int a = 1, b = 0, c = 0;
ArrayList list = obj.Solve(nums, a, b, c);
list = obj.sort(list, 0, (nums.length - 1));
for (int i = 0; i ");
       current = current.next();
       count++;
      if(count == 10)
        break;
    }       
   return sb.toString();
}
public static class Node {
    private Node next;
    private String data;
    public Node(String data) {
        this.data = data;
    }
    public String data() { 
      return data; 
    }        
    public void setData(String data) {
      this.data = data;
    }
    public Node next() { 
      return next; 
    }        
    public void setNext(Node next) {
      this.next = next; 
    }
    @Override
    public String toString() {
        return this.data;
    }
}
}
public class LoopInLinkedListTest { 
public static void main(String args[]) { 
  LinkedList linkedList = new LinkedList();
  if(false){
    linkedList.appendIntoTail(new LinkedList.Node("101")); 
    linkedList.appendIntoTail(new LinkedList.Node("201")); 
    linkedList.appendIntoTail(new LinkedList.Node("301")); 
    linkedList.appendIntoTail(new LinkedList.Node("401")); 
    System.out.println("Linked List : " + linkedList); 
  }else{
    linkedList.appendIntoTail(new LinkedList.Node("101"));
    LinkedList.Node cycle = new LinkedList.Node("201");
    linkedList.appendIntoTail(cycle);
    linkedList.appendIntoTail(new LinkedList.Node("301"));
    linkedList.appendIntoTail(new LinkedList.Node("401"));
    linkedList.appendIntoTail(cycle); 
    System.out.println("Linked List : " + linkedList);
  }         
  if(linkedList.isCyclic()){ 
      System.out.println("contains loop"); 
    }
    else{ 
      System.out.println("no loop"); 
    } 

}
}

Check if a linked list is a palindrome or not.
Ans.

class Node {
    int data;
    Node next;
    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}
public int size;
public Node head = null;
public Node tail = null;
public void addNode(int data) {
    Node node = new Node(data);
    if(head == null) {
        head = node;
        tail = node;
    } else {
        tail.next = node;
        tail = node;
    }
    size++;
}
public Node reverseList(Node temp) {
    Node current = temp;
    Node prevNode = null;
    Node nextNode = null;
    while(current != null) {
        nextNode = current.next;
        current.next = prevNode;
        prevNode = current;
        current = nextNode;
    }
    return prevNode;    
}
public void isPalindrome() {
    Node current = head;
    boolean flag = true;
    int mid = (size % 2 == 0) ? (size/2) : ((size+1)/2);
    for(int i = 1; i < mid; i++) {
        current = current.next;
    }
    Node revHead = reverseList(current.next);
    while(head != null && revHead != null) {
        if(head.data != revHead.data) {
            flag = false;
            break;
        }
        head = head.next;
        revHead = revHead.next;
    }
    if(flag) {
        System.out.println("\nPalondrome !");
    } else {
        System.out.println("\nnot Palindrome !");
    }
}
public void display() {
    Node current = head;
    while(current != null) {
        System.out.print(current.data + " ");
        current = current.next;
    }
    System.out.println(" ");
}
public static void main(String[] args) {
    LinkedListCheckPalindrome linkedList = new LinkedListCheckPalindrome();
    linkedList.addNode(1);
    linkedList.addNode(2);
    linkedList.addNode(3);
    linkedList.addNode(2);
    linkedList.addNode(1);
    linkedList.display();
    linkedList.isPalindrome();
}

Find pairs in the array such that its sum is closest to 0.
Ans.

public static void PairWithMinSum(int arr[]) {
    int minimumSum = arr[0] + arr[1];
    int pair1stIndex = 0;
    int pair2ndIndex = 1;
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            int tempSum = arr[i] + arr[j];
            if (Math.abs(tempSum) < Math.abs(minimumSum)) {
                pair1stIndex = i;
                pair2ndIndex = j;
                minimumSum = tempSum;
            }
        }
    }
    System.out.println( arr[pair1stIndex] + "  " + arr[pair2ndIndex]);
}
public static void main(String[] args) {
    int[] arr = { 2, 3, -1, 5, 6, -3};
    PairWithMinSum(arr);
}

Given an array of 0’s and 1’s in random order, you need to separate 0’s and 1’s in an array.
Ans.

public static int[] separate0s1sSolution1(int arr[]){
int count=0;
for (int i = 0; i < arr.length; i++) {
if(arr[i]==0)
{
count++;
}
}
for (int i = 0; i < count; i++) {
arr[i]=0;
}
for (int i = count; i < arr.length; i++) {
arr[i]=1;
}
return arr;
}

You are given an array, find the subarray with a given sum.
Ans.

public void findSubarraySum(int arr[], int target) {        
    int left = 0;
    int right = left + 1;
    int sum = 0;
    if (arr.length == 0) {
        System.out.println("-1");
        return;
    } 
    if (arr.length == 1) {          
        if (arr[0] == target) {
            System.out.println((arr[0] + 1) + " " + (arr[0] + 1));
        } else {
            System.out.println("-1");
        }
    }
    sum += arr[left] + arr[right];
    while (right < arr.length) {         
        if (sum == target) {
            System.out.println((left + 1) + " " + (right + 1));
            return;
        } else if (sum < target) {               
            right++;
            if (right = 0) {
        int n = in.nextInt();
        int target = in.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = in.nextInt();
        }       
        ss.findSubarraySum(arr, target);
    }
}

You are given an array, find the maximum subarray sum.
Ans. We will use Kadane’s algorithm here

public static void main(String[] args) {
    int[] Arr = {5,2,-1,-2,3,-5,1};
    findMaxSubArray(Arr);
}
public static void findMaxSubArray(int[] inputArray) {
    int maxStartIndex = 0;
    int maxEndIndex = 0;
    int maxSum = Integer.MIN_VALUE;
    int cumulativeSum = 0;
    int maxStartIndexUntilNow = 0;
    for (int currentIndex = 0; currentIndex  maxSum) {
            maxSum = cumulativeSum;
            maxStartIndex = maxStartIndexUntilNow;
            maxEndIndex = currentIndex;
        } 
        if (cumulativeSum < 0) {
            maxStartIndexUntilNow = currentIndex + 1;
            cumulativeSum = 0;
        }
    }
    System.out.println(maxSum);
}

Write a function to add two numbers represented by two linked list.
Ans.

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    if (l1 == null || l2 == null) {
        return l1 == null ? l2 : l1;
    }
    Stack s1 = new Stack();
    Stack s2 = new Stack();
    Stack result = new Stack();
    while (l1 != null) {
        s1.push(l1);
        l1 = l1.next;
    }
    while (l2 != null) {
        s2.push(l2);
        l2 = l2.next;
    }
    int carry = 0;
    while (!s1.isEmpty() || !s2.isEmpty()) {
        int sum = carry;
        if (!s1.isEmpty()) {
            sum += s1.pop().val;
        }
        if (!s2.isEmpty()) {
            sum += s2.pop().val;
        }
        carry = sum / 10;
        sum = sum % 10;
        result.push(new ListNode(sum));
    }
    if (carry != 0) {
        result.push(new ListNode(carry));
    }
    ListNode node = new ListNode(-1);
    ListNode temp = node;
    while (!result.isEmpty()) {
        node.next = result.pop();
        node = node.next;
    }
    return temp.next;
}

Write a program to find the first non-repeating character of a string.
Ans.

public static charsolve(String word) {
    Set duplicate = new HashSet();
    List nonDuplicate = new ArrayList();
    for (int i = 0; i < word.length(); i++) {
        char letter = word.charAt(i);
        if (duplicate.contains(letter)) {
            continue;
        }
        if (nonDuplicate.contains(letter)) {
            nonDuplicate.remove((Character) letter);
            duplicate.add(letter);
        } else {
            nonDuplicate.add(letter);
        }
    }
    return nonDuplicate.get(0);
}

Write a program to find the duplicate characters in a string.
Ans.

public static void main(String[] args) {
              String str = new String("duplicatestring");
              int count = 0;
              char[] chars = str.toCharArray();
              for (int i=0; i<str.length();i++) {
                          for(int j=i+1; j<str.length();j++) {
                                     if (chars[i] == chars[j]) {
                                                System.out.println(chars[j]);
                                                count++;
                                                break;
                                      }
                           }
               }
       }

Print all the substrings of a string.
Ans.

public static void PrintSubstring(String str, int length) {
    for (int i = 0; i < length; i++) {
        for (int j = i + 1; j  -1; i--) {
        sb.append(arr[i]).append(" ");
    }
    return sb.toString().trim();
}
public static void main(String args[]) {
    Scanner in = new Scanner(System.in);
    String s = in.nextLine();
    in.close();
    System.out.println(reverseLine(s));
}

Implement an algorithm of counting sort.
Ans.

public static void countingSort(int[] input, int k) {
    int counter[] = new int[k + 1];
    for(int i : input) {
        counter[i]++;
    }
    int ndx = 0;
    for(int i = 0; i < counter.length; i++) {
        while( 0 < counter[i]) {
            input[ndx++] = i;
            counter[i]--;
        }
    }
}
public static void main(String[] args) {
    int[] input = { 60, 40, 30, 20, 10, 40, 30, 60, 60, 20, 40, 30, 40 };
    int k = 60;
    countingSort(input, k);
    System.out.println(Arrays.toString(input));
}

Give a recursive function for Inorder traversal of a Binary Tree.
Ans.

void inOrderTraversal2(TreeNode node) {
    if (node == null) {
        return;
    }
    inOrderTraversal2(node.left);
    System.out.println(node.val);
    inOrderTraversal2(node.right);
}

Check if a given Binary tree is height balanced or not. You will be given a root to that tree.
Ans.

class TreeNode {
    int value;
    TreeNode left, right;
}
public boolean isBalanced(TreeNode root) {
    if (root == null)
        return true;
    int left = getHeight(root.left);
    int right = getHeight(root.right);
    if (Math.abs(left - right) <= 1)
        return isBalanced(root.left) && isBalanced(root.right);
    else
        return false;
}
public int getHeight(TreeNode root) {
    if (root == null)
        return 0;
    else {
        int left = getHeight(root.left);
        int right = getHeight(root.right);
        return Math.max(left, right) + 1;
    }
}

Write a program to invert a Binary Tree.
Ans.

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) {
        val = x;
    }
}
public TreeNode invertTree(TreeNode root) {
    if(root == null)
        return null;
    TreeNode result = new TreeNode(root.val);        
    result.right = this.invertTree(root.left);
    result.left = this.invertTree(root.right);        
    return result;
}

Write a program to sort a stack recursively.
Ans.

public static void main(String args[]) {
    Stack stack = new Stack();
    stack.push(1);
    stack.push(2);
    stack.push(4);
    stack.push(3);
    stack.push(-2);     
    for (Integer i: stack) {
        System.out.print(i + ", ");
    }
    System.out.println();       
    sort(stack);
    for (Integer i: stack) {
        System.out.print(i + ", ");
    }
    System.out.println();
}   
public static void sort(Stack stack) {
    removeElement(stack);
}   
private static void removeElement(Stack stack) {
    if(!stack.isEmpty()) {
        int tmp = stack.pop();
        removeElement(stack);
        insertElement(tmp, stack);
    }
}
private static void insertElement(int tmp, Stack stack) {
    if(stack.isEmpty() || tmp >= stack.peek()) {
        stack.push(tmp);
    }
    else {
        int poped = stack.pop();
        insertElement(tmp, stack);
        stack.push(poped);
    }
}

Implement a queue using two stacks.
Ans.

Stack entryStack;
Stack exitStack;
public MyQueue() {
    this.entryStack = new Stack();
    this.exitStack = new Stack();
}
public void push(int x) {
    this.entryStack.push(x);
}    
public int pop() {
    while(!this.entryStack.isEmpty()){
        this.exitStack.push(this.entryStack.pop());
    }
    int retValue = this.exitStack.pop();
    while(!this.exitStack.isEmpty()){
        this.entryStack.push(this.exitStack.pop());
    }
    return retValue;
}
public int peek() {
    while(!this.entryStack.isEmpty()){
        this.exitStack.push(this.entryStack.pop());
    }
    int retValue = this.exitStack.peek();
    while(!this.exitStack.isEmpty()){
        this.entryStack.push(this.exitStack.pop());
    }
    return retValue;
}    
public boolean empty() {
    return this.entryStack.isEmpty();
}

Implement an LRU cache in Java.
Ans.

class Node {
    int key;
    int value;
    Node prev;
    Node next;
    public Node(int key, int value){
        this.key = key;
        this.value = value;
    }
}    
class DoublyLinkedList {
    Node head;
    Node tail;        
    public boolean isEmpty(){
        return this.head == null;
    }        
    public void addToHead(Node node){
        if(this.isEmpty()){
            this.head = this.tail = node;
            node.prev = null;
            node.next = null;
        }
        else{
            node.prev = null;
            node.next = this.head;
            this.head.prev = node;
            this.head = node;
        }
    }        
    public Node deleteFromTail(){
        Node node = this.tail;
        if(this.head == this.tail){
            this.head = this.tail = null;
        }
        else{
            this.tail = this.tail.prev;
            this.tail.next = null;   
        }
        return node;
    }        
    public void moveToHead(Node node){
        if(this.head == node)
            return;
        else if(this.tail == node){
            this.deleteFromTail();
            this.addToHead(node);
        }
        else{
            node.prev.next = node.next;
            if(node.next != null)
                node.next.prev = node.prev;
            node.next = null;
            node.prev = null;
            this.addToHead(node);
        }
    }
}    
HashMap nodes;
DoublyLinkedList list;
int count, capacity;
public LRUCache(int capacity) {
    this.capacity = capacity;
    this.count = 0;
    this.nodes = new HashMap();
    this.list = new DoublyLinkedList();
}    
public int get(int key) {
    if(nodes.containsKey(key)){
        Node node = nodes.get(key);
        this.list.moveToHead(node);
        return node.value;
    }
    else
        return -1;
}    
public void put(int key, int value) {
    if(nodes.containsKey(key)){
        Node node = nodes.get(key);
        node.value = value;
        this.list.moveToHead(node);
    }
    else{
        Node node = new Node(key, value);
        nodes.put(key, node);
        this.count++;
        this.list.addToHead(node);
        if(this.count > this.capacity){
            Node toDelete = this.list.deleteFromTail();
            this.nodes.remove(toDelete.key);
            this.count--;
        }
    }
}
/**
* Your LRUCache object will be instantiated and called as such:
* LRUCache obj = new LRUCache(capacity);
* int param_1 = obj.get(key);
* obj.put(key,value);
*/

Traverse the Binary tree in zig-zag way and print the nodes.
Ans.

public class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode() {}
      TreeNode(int val) { this.val = val; }
      TreeNode(int val, TreeNode left, TreeNode right) {
          this.val = val;
          this.left = left;
          this.right = right;
      }
  }
public List<List> zigzagLevelOrder(TreeNode root) {
        List<List> result = new LinkedList();
        if(root == null) return result;
        Queue queue = new LinkedList();
        queue.add(root);
        boolean direction = false;
        while(queue.size() > 0){
            direction = !direction;
            Queue level = new LinkedList();
            List rlevel = new LinkedList();
            while(queue.size() > 0){
                TreeNode node = queue.poll();
                if(direction){
                    rlevel.add(node.val);
                }else{
                    rlevel.add(0,node.val);
                }
                if(node.left != null) level.add(node.left);
                if(node.right != null) level.add(node.right);
            }
            result.add(rlevel);
            queue = level;
        }
        return result;
    }

Write a program to traverse a graph in BFS.
Ans.

public class Graph {
private final int v;
private final LinkedList[] adjacents;
public Graph(int v) {
    this.v = v;
    adjacents = new LinkedList[v];
    for (int i = 0; i < v; ++i) {
        adjacents[i] = new LinkedList();
    }
}
void addEdge(int v, int e) {
    adjacents[v].add(e);
}
void BFS(int start) {
    boolean visited[] = new boolean[v];
    LinkedList queue = new LinkedList();
    visited[start] = true;
    queue.add(start);
    while (!queue.isEmpty()) {
        start = queue.poll();
        System.out.print(start + " ");
        Iterator i = adjacents[start].listIterator();
        while (i.hasNext()) {
            int n = i.next();
            if (!visited[n]) {
                visited[n] = true;
                queue.add(n);
            }
        }
    }
}
public static void main(String[] args) {
    Graph graph = new Graph(4);
    graph.addEdge(0, 3);
    graph.addEdge(0, 1);
    graph.addEdge(1, 0);
    graph.addEdge(2, 3);
    graph.addEdge(3, 0);
    graph.addEdge(3, 2);
    graph.addEdge(3, 3);        
    graph.BFS(0);
}
}

Write a function to insert a node in Binary Search Tree.
Ans.

static Node Insert(Node root, int value){
Node newNode = new Node();
newNode.data = value;
newNode.left = null;
newNode.right = null;    
if (root == null) {
    return newNode;    }

addNode(root, newNode);
return root;
}
static void addNode(Node root, Node newNode) {
if (newNode.data < root.data) {
    if (root.left == null) {
        root.left = newNode;
    } else {
        addNode(root.left, newNode);
    }
} else {
    if (root.right == null) {
        root.right = newNode;
    } else {
        addNode(root.right, newNode);
    }
} 
}

Suppose you are given an array and you are asked to find the triplets whose sum will be a given target sum. If your array contains such a triplet return the sum else -1.
Ans.

public ArrayList<ArrayList> threeSum(int[] num) {
    ArrayList<ArrayList> result = new ArrayList<ArrayList>();
    if (num.length < 3) {
        return result;
    }

    Arrays.sort(num);

    for (int i = 0 ; i < num.length - 2 ; i++) {
        if (i != 0 && num[i] == num[i-1]) {
            continue;
        }
        int left = i + 1;
        int right = num.length - 1;

        while (left < right) {
            int sum = num[i] + num[left] + num[right];
            if (sum  0) {
                right--;
            } else {
                ArrayList temp = new ArrayList();
                temp.add(num[i]);
                temp.add(num[left]);
                temp.add(num[right]);
                result.add(temp);
                do {
                    left++;
                } while (left  left && num[right] == num[right+1]);
            }
        }
    }
    return result;
}

Find the Kth largest element in an array.
Ans.

public int kthLargestElement(int k, ArrayList nums) {
    if (nums == null || nums.size() == 0) {
        return 0;
    }
    return helper(nums, 0, nums.size() - 1, nums.size() - k);
}    
public void swap( ArrayListnums, int x, int y){
    int temp = nums.get(x);
    nums.set(x, nums.get(y));
    nums.set(y, temp);
}    
public int helper( ArrayList nums, int start, int end, int mid) {
    int pivot = end;
    int num = nums.get(pivot);
    int low = start;
    int high = end;
    while (low < high) {
        while(low < high && nums.get(low) < num) {
            low++;
        }
        while(low = num) {
            high--;
        }
        swap(nums, low, high);
    }
    swap(nums, low, pivot);
    if (low == mid) {
        return nums.get(low);
    } else if (low < mid) {
        return helper(nums, low + 1, end, mid);
    } else {
        return helper(nums, start, low - 1, mid);
    }
}

Top 30 Java Programming interview questions

Leave a Reply Cancel reply

Multiple Granularity Locking in DBMS

Log-based Recovery in Database Management Systems

The Problem of Redundancy in Database

Strategies for Schema Design in DBMS

Quantum Cryptography

Introduction to Sniffers

Sign in to your account

Login via OTP

Login via OTP

Register with PrepBytes

Leave a Reply Cancel reply