Blackbuck interview Questions

Author: anubhav1006

src/DSA/Arrays/KthLargestElement.java

@@ -0,0 +1,67 @@
+package DSA.Arrays;
+
+import java.util.Arrays;
+
+public class KthLargestElement {
+ public static void main(String[] args) {
+ int[] arr = {5,2, 67, 34, 76, 345};
+ int k=4;
+
+ System.out.println("Kth largest element: "+ kthLargest(arr, k));
+ System.out.println(Arrays.toString(heap));
+ }
+
+ private static int kthLargest(int[] arr, int k) {
+ initHeap(k);
+ for(int i=0;i<k;i++){
+ heap[i] = arr[i];
+ }
+ for(int i=k;i<arr.length;i++){
+ if(arr[i]>heap[0]) {
+ heap[0] = arr[i];
+ heapify(0);
+ }
+ }
+ return heap[0];
+ }
+ private static int[] heap;
+ private static int heapSize;
+ private static int left(int i){return (2*i)+1;}
+ private static int right(int i){return (2*i)+2;}
+ private static int parent(int i){return (i-1)/2;}
+
+ private static void initHeap(int size){
+ heapSize = size;
+ heap = new int[heapSize];
+ }
+
+ private static void heapify(int i){
+ int l = left(i);
+ int r = right(i);
+ int smallest = i;
+ if(l<heapSize && heap[l]<heap[smallest])
+ smallest=l;
+ if(r<heapSize && heap[r]<heap[smallest])
+ smallest=r;
+
+ if (smallest!=i){
+ swap(smallest, i);
+ heapify(smallest);
+ }
+ }
+
+ private static void swap(int smallest, int i) {
+ int temp = heap[smallest];
+ heap[smallest] = heap[i];
+ heap[i] = temp;
+ }
+
+ private static int extractMin(){
+ int min = heap[0];
+ heap[0] = heap[heapSize-1];
+ heapSize--;
+ heapify(0);
+ return min;
+ }
+
+}

src/DSA/Graphs/CityAttractions.java

@@ -27,9 +27,9 @@ static class Edge{
  //edges = edgeTime.length;
  adjacencyList = new LinkedList[v];
  timeMap = new HashMap<>();
- /*edgeList = new LinkedList[edges];
+ /*edgeList = new ReverseLinkedList[edges];
  for(int i=0;i<edges;i++){
- edgeList[i] = new LinkedList<>();
+ edgeList[i] = new ReverseLinkedList<>();
  }*/
  this.weight = weight;
  //this.edgeTime = edgeTime;

src/DSA/Graphs/DetectCycle.java

@@ -8,15 +8,15 @@ public class DetectCycle {
  static class Graph {
  int v;
  int e;
- //LinkedList<Edges>[] adjList;
+ //ReverseLinkedList<Edges>[] adjList;
  Edges[] edges;
 
  Graph(int v, int e) {
  this.v = v;
  this.e = e;
- /*adjList = new LinkedList[v];
+ /*adjList = new ReverseLinkedList[v];
  for(int i=0;i<v;i++){
- adjList[i] = new LinkedList<>();
+ adjList[i] = new ReverseLinkedList<>();
  }*/
  edges = new Edges[this.e];
  }

src/DSA/Graphs/kCores.java

@@ -119,7 +119,7 @@ private void dfsUtil(int s, boolean[] visited) {
  }
  }
 
- *//*int size(LinkedList<Integer> ll){
+ *//*int size(ReverseLinkedList<Integer> ll){
  int size=0;
  Iterator it = ll.listIterator();
  while (it.hasNext()){

src/DSA/LinkedList/DeleteCurrentNode.java

@@ -0,0 +1,61 @@
+package DSA.LinkedList;
+
+public class DeleteCurrentNode {
+
+ public static void main(String[] args) {
+ node head = new node(1);
+ addNext(head,2);
+ addNext(head,3);
+ addNext(head,4);
+ addNext(head,5);
+ addNext(head,6);
+ addNext(head,7);
+ addNext(head,8);
+ addNext(head,9);
+ node toBeDeleted = head.next.next.next;
+ System.out.println("Before conversion: ");
+ printLL(head);
+ System.out.println("");
+ convert(toBeDeleted);
+ System.out.println("After conversion: ");
+ printLL(head);
+
+ }
+
+ private static void convert(node toBeDeleted) {
+ if(toBeDeleted==null)
+ return;
+ if (toBeDeleted.next==null)
+ toBeDeleted =null;
+ node temp = toBeDeleted.next;
+ toBeDeleted.next = toBeDeleted.next.next;
+ toBeDeleted.data = temp.data;
+ }
+
+ static class node{
+ int data;
+ node next;
+
+ public node(int data) {
+ this.data = data;
+ next = null;
+ }
+ }
+
+ static void printLL(node head){
+ while(head!=null){
+ System.out.print(head.data+" ");
+ head = head.next;
+ }
+ }
+
+ static void addNext(node head, int data){
+ if(head ==null)
+ head = new node(data);
+ while(head.next!=null){
+ head = head.next;
+ }
+ head.next = new node(data);
+ }
+
+}

src/DSA/LinkedList/FirstLastLinkedList.java

@@ -0,0 +1,91 @@
+package DSA.LinkedList;
+
+public class FirstLastLinkedList {
+ public static void main(String[] args) {
+ node node = new node(1);
+ addNext(node,2);
+ addNext(node,3);
+ addNext(node,4);
+ addNext(node,5);
+ addNext(node,6);
+ addNext(node,7);
+ addNext(node,8);
+ addNext(node,9);
+ System.out.println("Before conversion: ");
+ printLL(node);
+ System.out.println("");
+ convert(node);
+ System.out.println("After conversion: ");
+ printLL(node);
+
+ }
+
+ static class node{
+ int data;
+ node next;
+
+ public node(int data) {
+ this.data = data;
+ next = null;
+ }
+ }
+
+ static void printLL(node head){
+ while(head!=null){
+ System.out.print(head.data+" ");
+ head = head.next;
+ }
+ }
+
+ static void addNext(node head, int data){
+ if(head ==null)
+ head = new node(data);
+ while(head.next!=null){
+ head = head.next;
+ }
+ head.next = new node(data);
+ }
+
+ static void convert(node head){
+ if(head==null || head.next==null)
+ return;
+ node mid = getMiddle(head);
+ node head2 = mid.next;
+ mid.next = null;
+
+ head2 = reverseLL(head2);
+ node head1 = head;
+ while(head2!=null){
+ node temp = head1.next;
+ head1.next = head2;
+ head2 = head2.next;
+ head1.next.next = temp;
+ head1= head1.next.next;
+ }
+
+ }
+
+ static node getMiddle(node head){
+ if(head.next.next==null)
+ return head.next;
+ node fast_ptr = head, slow_ptr = head;
+ while(fast_ptr.next!=null && fast_ptr.next.next!=null){
+ fast_ptr=fast_ptr.next.next;
+ slow_ptr = slow_ptr.next;
+ }
+
+ return slow_ptr;
+ }
+
+ static node reverseLL(node head){
+ node prev=null, current = head, next;
+
+ while(current!=null){
+ next = current.next;
+ current.next = prev;
+ prev = current;
+ current = next;
+ }
+ return prev;
+ }
+}

src/DSA/LinkedList/MergeLists.java

@@ -138,16 +138,3 @@ Node recMergeSorted(Node head1, Node head2){
 
 }
 
-
-/*This is a function problem.You only need to complete the function given below*/
-/*
- Merge two linked lists
- head pointer input could be NULL as well for empty list
- Node is defined as
- class Node
- {
- int data;
- Node next;
- Node(int d) {data = d; next = null; }
- }
-*/

src/DSA/LinkedList/MergeSort.java

@@ -69,6 +69,17 @@ private static Node middleElement(Node head) {
  return slowptr;
  }
 
+ private static Node midElement(Node head){
+ if(head==null)
+ return null;
+ Node slow=head, fast=head;
+ while(fast.next!=null){
+ slow = slow.next;
+ fast = fast.next.next;
+ }
+ return slow;
+ }
+
  static void printList(Node head) {
  if (head == null)
  System.out.println("List is empty");
@@ -87,7 +98,7 @@ public static void main(String[] args) {
  node = mergeSort(node);
  printList(node);
 
- System.out.println("");
+ //System.out.println(midElement(node).data);
 
  Set<Node> nodeSet= new HashSet<>();