Standard Linked List Questions

Add2LL.java

@@ -0,0 +1,79 @@
+package LinkedList;
+
+import LinkedList.LinkedList.Node;
+import LinkedList.LinkedList.LinkedList;
+public class Add2LL {
+	public static void main(String[] args) {
+		LinkedList l1 = new LinkedList();
+		LinkedList l2 = new LinkedList();
+		l1.addLast(1);
+		l2.addLast(1);
+		l2.addLast(9);
+		l2.addLast(9);
+		l2.addLast(9);
+		Node ans = add(l1.head, l2.head);
+		display(ans);
+	}
+	static void display(Node node){
+		while(node!=null){
+			System.out.print(node.data+" ");
+			node = node.next;
+		}
+		System.out.println();
+	}
+	static Node add(Node n1, Node n2){
+		n1 = reverse(n1);
+		n2 = reverse(n2);
+		int s1 = getSize(n1);
+		int s2 = getSize(n2);
+		if(s1>s2){
+			add0(n2,s1-s2);
+		}else{
+			add0(n1,s2-s1);
+		}
+		int carry = 0;
+		Node tail = n1;
+		// display(n1);
+		// display(n2);
+		while(n1!=null){
+			int temp = n1.data;
+			n1.data = (n2.data+temp+carry)%10;
+			carry = (n2.data+temp+carry)/10;
+			if(n1.next==null && carry!=0){
+				n1.next = new Node(carry);
+				break;
+			}
+			n1 = n1.next;
+			n2 = n2.next;
+		}
+		return reverse(tail);
+
+	}
+	static void add0(Node n, int s){
+		Node temp = n;
+		while(temp.next!=null){
+			temp = temp.next;
+		}
+		while(s>0){
+			temp.next = new Node(0);
+			temp = temp.next;
+			s--;
+		}
+	}
+	static int getSize(Node n1){
+		int ans =0 ;
+		while(n1!=null){
+			n1 = n1.next;
+			ans++;
+		}
+		return ans;
+	}
+	static Node reverse(Node n1){
+		if(n1==null||n1.next==null) return n1;
+		Node node = reverse(n1.next);
+		n1.next.next = n1;
+		n1.next=null;
+		return node;
+	}
+
+}

AddInADoublyLL.java

@@ -0,0 +1,36 @@
+package LinkedList;
+import LinkedList.LinkedList.*;
+public class AddInADoublyLL {
+	public static void main(String[] args) {
+
+	}
+	static void insert(DLL head_ref, int x, int data){
+		DLL node = new DLL(data);
+		if(head_ref==null){
+		    head_ref = node;
+		}
+		if(x==0){
+		    node.next = head_ref;
+		    head_ref.prev = node;
+		    head_ref = node;
+		}
+		DLL temp = head_ref;
+		while(temp!=null && x>0){
+		    temp = temp.next;
+		    x--;
+		}
+		if(temp!=null){
+		    if(temp.next==null){
+		        node.prev = temp;
+		        temp.next = node;
+		    }
+		    else{
+		        temp.next.prev = node;
+		        node.next = temp.next;
+		        node.prev = temp;
+		        temp.next = node;
+		      //  node.next.prev = node;
+		    }
+		}
+	}
+}

DLL.java

@@ -0,0 +1,11 @@
+package LinkedList.LinkedList;
+
+public class DLL {
+	public int data;
+	public DLL prev;
+	public DLL next;
+	public DLL(int data){
+		this.data = data;
+		prev = next = null;
+	}
+}

DeleteAndReverseInLL.java

@@ -0,0 +1,48 @@
+package LinkedList;
+
+import LinkedList.LinkedList.*;
+public class DeleteAndReverseInLL {
+	public static void main(String[] args) {
+		LinkedList ll = new LinkedList();
+		ll.addLast(2);
+		ll.addLast(5);
+		ll.addLast(7);
+		ll.addLast(8);
+		ll.addLast(10);
+		ll.tail.next = ll.head;
+		ll.head = delete(ll.head, 8);
+		display(ll.head);
+	}
+	static void display(Node node){
+		Node temp = node;
+		while(temp.next!=node){
+			System.out.print(temp.data+"->");
+			temp = temp.next;
+		}
+		System.out.print(temp.data+" ");
+
+	}
+	static Node delete(Node node, int data){
+		if(node==null) return null;
+		if(node.data==data && node.next==null) return null;
+		Node temp = node;
+		while(temp.next!=null && temp.next.data!=data){
+			temp = temp.next;
+		}
+		temp.next = temp.next.next;
+		Node ans =  reverse(node);
+		node.next = ans;
+		return ans;
+
+	}
+	static Node reverse(Node head){
+		return reverseHelper(head,head);
+	}
+	static Node reverseHelper(Node node, Node head){
+		if(node.next == head) return node;
+		Node ans = reverseHelper(node.next, head);
+		node.next.next = node;
+		node.next = null;
+		return ans;
+	}
+}

DeleteMidOfLL.java

@@ -0,0 +1,29 @@
+package LinkedList;
+
+import LinkedList.LinkedList.*;
+public class DeleteMidOfLL {
+	public static void main(String[] args) {
+		LinkedList ll = new LinkedList();
+		ll.addLast(1);
+		ll.addLast(2);
+		ll.addLast(3);
+		ll.addLast(4);
+		ll.addLast(5);
+		ll.addLast(6);
+		ll.head = delete(ll.head);
+		ll.display();
+	}
+	static Node delete(Node node){
+		if(node==null||node.next==null) return null;
+		Node slow = node;
+		Node fast = node;
+		Node tail = slow;
+		while(fast!=null && fast.next!=null){
+			fast = fast.next.next;
+			tail = slow;
+			slow = slow.next;
+		} 
+		tail.next = slow.next;
+		return node;
+	}
+}

DeleteNNodesAfterMNodes.java

@@ -0,0 +1,49 @@
+package LinkedList;
+
+import LinkedList.LinkedList.*;
+public class DeleteNNodesAfterMNodes {
+	public static void main(String[] args) {
+		LinkedList ll = new LinkedList();
+		ll.addLast(9);
+		ll.addLast(1);
+		ll.addLast(3);
+		ll.addLast(5);
+		ll.addLast(9);
+		ll.addLast(4);
+		ll.addLast(10);
+		ll.addLast(1);
+		ll.head = delete(ll.head, 2, 1);
+		ll.display();
+	}
+	static Node delete(Node node , int m, int n){
+		if(m==0 && n==0) return node;
+		if(m==0) return null;
+		Node head = node;
+		while(head!=null){
+			int skip = m;
+			// skipping
+			while(head!= null && skip>1){
+				head = head.next;
+				skip--;
+			}
+			Node prev = head;
+			if(head!=null){
+				head = head.next;
+			}
+			int del = n;
+			//delting
+			while(head!=null && del>1){
+				head = head.next;
+				del--;
+			}
+			if(head!=null){
+				Node next = head.next;
+				head = head.next;
+				prev.next = next;
+			}else{
+				prev.next = null;
+			}
+		}
+		return node;
+	}
+}

DeleteNodesHavingGreaterValueOnRight.java

@@ -0,0 +1,27 @@
+package LinkedList;
+import LinkedList.LinkedList.*;
+public class DeleteNodesHavingGreaterValueOnRight {
+	public static void main(String[] args) {
+		LinkedList ll = new LinkedList();
+		ll.addLast(12);
+		ll.addLast(15);
+		ll.addLast(10);
+		ll.addLast(11);
+		ll.addLast(5);
+		ll.addLast(6);
+		ll.addLast(2);
+		ll.addLast(3);
+		ll.head = delete(ll.head);
+		ll.display();
+	}
+	static Node delete(Node node){
+		//elegant solution
+		if(node==null||node.next==null) return node;
+		Node temp = delete(node.next);//returns max node value on right
+		if(temp.data>node.data) return temp;
+		else{
+			node.next = temp;
+			return node;
+		}
+	}
+}

DeleteWithoutHeadPointer.java

@@ -0,0 +1,12 @@
+package LinkedList;
+
+import LinkedList.LinkedList.*;
+public class DeleteWithoutHeadPointer {
+	public static void main(String[] args) {
+
+	}
+	static void delete(Node node){
+		node.data = node.next.data;
+		node.next = node.next.next;
+	}
+}

DeletingNodesInDoublyLinkedList.java

@@ -0,0 +1,32 @@
+package LinkedList;
+
+import LinkedList.LinkedList.*;
+public class DeletingNodesInDoublyLinkedList {
+	public static void main(String[] args) {
+
+	}
+	static DLL delete(DLL node, int x){
+		{
+		// Your code here
+		 DLL temp = node;
+			if(node==null) return null;
+			while(node!=null && x>1){
+				node = node.next;
+				x--;
+			}
+			if(node!=null && node.next!=null && node.prev!=null){
+				DLL t = node.prev;
+				node.prev.next = node.next;
+				node.next.prev = t;
+			}
+			else if(node.prev==null){
+				temp = node.next;
+				node.next=null;
+			}
+			else if(node.next==null){
+				node.prev.next = null;
+			}
+			return temp;
+
+	}
+}}

DesignAPhoneDirectory.java

@@ -0,0 +1,45 @@
+package LinkedList;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+public class DesignAPhoneDirectory {
+	/*
+	 * Design a Phone Directory which supports the following operations:
+
+		get: Provide a number which is not assigned to anyone.
+		check: Check if a number is available or not.
+		release: Recycle or release a number.
+	 */
+	int max;
+	HashSet<Integer> set;
+	LinkedList<Integer> queue;
+	/**
+	 * 
+	 * @param maxNumbers - Maximum numbers that can be stored in the phone Directory
+	 */
+	public DesignAPhoneDirectory(int maxNumbers){
+		set = new HashSet<>();
+		queue = new LinkedList<>();
+		for(int i=0;i<maxNumbers;i++){
+			queue.offer(i);
+		}
+		max = maxNumbers-1;
+	}
+		/**
+		 * @return return an available number
+		 */
+		public int get() {
+			if(queue.isEmpty()) return -1;
+			int e = queue.poll();
+			set.add(e);
+			return e;
+		}
+		public void recycle(int number){
+			if(set.contains(number)){
+				set.remove(number);
+				queue.offer(number);
+			}
+		}
+	}
+
+