Cleaning up repo

Author: deepak-malik

src/com/deepak/LinkedList/BasicOperations.java

@@ -1,7 +1,7 @@
 /**
  * Data-Structures-And-Algorithms-in-Java
  */
-package com.deepak.Arrays;
+package com.deepak.data.structures.Arrays;
 
 /**
  * Class to hold implementation of basic operations in java

src/com/deepak/LinkedList/DoublyLinkedList.java

@@ -2,7 +2,7 @@
  * Data-Structures-And-Algorithms-in-Java
  * ConcurrentHashMapImplementation.java
  */
-package com.deepak.Hashing;
+package com.deepak.data.structures.Hashing;
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;

src/com/deepak/LinkedList/LinkedListConcepts

@@ -2,7 +2,7 @@
  * Data-Structures-And-Algorithms-in-Java
  * ConcurrentModificationException.java
  */
-package com.deepak.Hashing;
+package com.deepak.data.structures.Hashing;
 
 import java.util.HashMap;
 import java.util.Iterator;

src/com/deepak/Arrays/ArraysConcepts renamed to src/com/deepak/data/structures/Arrays/ArraysConcepts

@@ -2,7 +2,7 @@
  * Data-Structures-And-Algorithms-in-Java
  * CustomHashMap.java
  */
-package com.deepak.Hashing;
+package com.deepak.data.structures.Hashing;
 
 import java.util.Map;
 import java.util.Objects;

src/com/deepak/Arrays/BasicOperations.java renamed to src/com/deepak/data/structures/Arrays/BasicOperations.java

@@ -0,0 +1,61 @@
+package com.deepak.data.structures.Hashing;
+
+import java.util.Map;
+import java.util.Objects;
+
+public class CustomHashTable<K, V> {
+
+	/**
+	 * This is a node representation of Linked List
+	 * @author Deepak
+	 *
+	 * @param <K>
+	 * @param <V>
+	 */
+	static class Entry<K, V> {
+		final int hash;
+		final K key;
+		V value;
+		Entry<K, V> next;
+
+		/**
+		 * Constructor for creating a entry
+		 * @param hash
+		 * @param key
+		 * @param value
+		 * @param next
+		 */
+		public Entry(int hash, K key, V value, Entry<K, V> next) {
+			this.hash = hash;
+			this.key = key;
+			this.value = value;
+			this.next = next;
+		}
+
+		/**
+		 * HashCode implementation for entry
+		 */
+		public final int hashCode() {
+			return Objects.hashCode(key) ^ Objects.hashCode(value);
+		}
+
+		/**
+		 * Method to check if two objects are equal
+		 */
+		public final boolean equals(Object o) {
+			if (o == this) {
+				return true;
+			}
+			if (o instanceof Map.Entry) {
+				Map.Entry<?,?> e = (Map.Entry<?,?>)o;
+				if (Objects.equals(key, e.getKey()) &&
+						Objects.equals(value, e.getValue())) {
+					return true;
+				}
+			}
+			return false;
+		}
+
+	}
+
+}

src/com/deepak/Hashing/ConcurrentHashMap.md renamed to src/com/deepak/data/structures/Hashing/ConcurrentHashMap.md

@@ -2,7 +2,7 @@
  * Data-Structures-And-Algorithms-in-Java
  * HashCodeAndEquals.java
  */
-package com.deepak.Hashing;
+package com.deepak.data.structures.Hashing;
 
 import java.util.HashMap;
 import java.util.HashSet;

src/com/deepak/Hashing/ConcurrentHashMapImplementation.java renamed to src/com/deepak/data/structures/Hashing/ConcurrentHashMapImplementation.java

@@ -0,0 +1,38 @@
+``` HashTable v/s HashMap
+Before this, I would suggest to go through the topic Iterator V/S Enumeration here.
+
+There are some significant factors that makes both of these data structures different
+
+1. Synchronization or Thread Safety
+- This is the most important difference between the two. 
+- Hash tables are synchronized and thread safe whereas Hash maps are not.
+
+2. Null keys and Null values
+- HashMap allows one null key and multiple null values, whereas hash table doesn't allow neither null values not null keys.
+
+3. Iterating the Values
+- Values in hash map are iterated using an iterator, whereas in hash table values are iterated using enumerator.
+- Only Vector other then hash table uses enumerator to iterate through elements. 
+
+4. Fail Fast Iterator
+- Iterator in hash map is fail fast iterator, whereas enumerator for hash table is not.
+- If hash table is structurally modified at any time after the iterator is created other then iterators own remove method, then it will throw Concurrent Modification exception.
+- Structural modification means adding or removing elements from the collection.
+
+5. Super class and Legacy
+- HashTable is a subclass of Dictionary, which is now obsolete from JDK 1.7
+
+6. Performance 
+- HashMap is much faster and uses less memory because it is not synchronized. 
+
+Similarities :
+1. Order of elements 
+- Cannot be guaranteed, because both of these work based on the hashing logic. use Linked Hash map for that
+2. Both of them comes from Map interface.
+3. Both provides constant time for performance for put and get methods, assuming that objects are distributed uniformly.
+4. Both works on the principle of hashing
+
+When to use?
+Avoid using HashTable, as they are obsolete now, ConcurrentHashMap has replaced it.
+Single threaded apps - use HashMap
+ 

src/com/deepak/Hashing/ConcurrentModificationException.java renamed to src/com/deepak/data/structures/Hashing/ConcurrentModificationException.java

@@ -0,0 +1,19 @@
+Though both of us allows to traverse through the collection of elements. 
+
+Both Iterator and Enumeration are interfaces, found in java.util package
+1. Iterator has 3 methods, 
+    - hasNext()
+    - next()
+    - remove()
+2. Enumeration has 2 methods, 
+    - hasMoreElements()
+    - nextElement()
+
+- Iterator differs from Enumeration because iterator allows the caller to remove the elements while traversing through the collection. Enumeration doesn't have remove method. Enumeration is a legacy class and not all data structures supports it. for ex. Vector supports enumeration but a array list doesn't. On the other hand iterator is a standard class for traversal of elements.
+- Enumeration is older and exists from JDK 1.0, whereas iterator was introduced later.
+- Functionality of enumeration interface is duplicated in Iterator with some extra features on top of it.
+- Enumeration acts as read only interface, because it has methods only to traverse the elements. Whereas, iterator can modify the collection too, because remove method exits in it.
+- Iterator is more secure and safe, because it does not allow any other thread to modify the collection if one thread is working on the collection already. Iterator will throw ConcurrentModification Exception in this use case. 
+
+When to use?
+- Use enumeration when only reading of elements is associated. 

src/com/deepak/Hashing/CustomHashMap.java renamed to src/com/deepak/data/structures/Hashing/CustomHashMap.java

@@ -2,7 +2,7 @@
  * Data-Structures-And-Algorithms-in-Java
  * WeakHashMapImplementation.java
  */
-package com.deepak.Hashing;
+package com.deepak.data.structures.Hashing;
 
 import java.util.Map;
 import java.util.WeakHashMap;

src/com/deepak/data/structures/Hashing/CustomHashTable.java

@@ -0,0 +1,5 @@
+package com.deepak.data.structures.LinkedList;
+
+public class BasicOperations {
+
+}

src/com/deepak/Hashing/HashCode&EqualsContract.md renamed to src/com/deepak/data/structures/Hashing/HashCode&EqualsContract.md

@@ -0,0 +1,5 @@
+package com.deepak.data.structures.LinkedList;
+
+public class DoublyLinkedList {
+
+}

src/com/deepak/Hashing/HashCodeAndEquals.java renamed to src/com/deepak/data/structures/Hashing/HashCodeAndEquals.java

@@ -0,0 +1,35 @@
+## Linked List
+</br>
+
+We already have arrays, what's the problem with it that we have to move with a new data structure??
+
+- Arrays are fixed size data structure. Once created in memory we cannot cross that limit. 
+Resizing can be done but there is no surety that we will have that much memory available later on.
+	For ex. We created a array of initial size 10. Application is running and it has taken lot of memory. 
+		We got a need to increase the size of out array to 25 now. We don't have enough contiguous memory to create it.
+		Problem !!!!
+2. Array insertion and deletion may require adjustment in size. (Overhead) 		
+3. The best part with Arrays is, each element can be accessed in a very efficient manner since index is known.
+Applications which can be better managed without using a contiguous memory based data structure, Linked lists are introduced.
+
+Linked list is a collection of objects (called Nodes) connected to each other in the memory. 
+Each Node contains some data and pointer to some other Node. Last node points to null reference.
+Entry point to the linked list is called first node or head node. If list is empty, head will be null.
+Unlike arrays, nodes cannot be accessed using index. Also they don't take contiguous memory.
+If we want to traverse through the list, we have to start from head and then check each element.
+
+### Types of Linked List
+- Singly Linked List - Provides access to list from the head node. Traversal is allowed only one way and there is no going back.
+- Doubly Linked List - Provides access to list from head and tail nodes. Traversal is allowed from both the sides of the list.
+- Circular Linked List - Provides access to list from the head node. But pointer of last node again points back to first node.
+
+### Operations on Linked List
+- Traversing through linked list
+- Check if list is empty
+- Check the size of the list
+- Inserting a element in the list
+- Search a element by index
+- Search a element by value
+- Delete a element from the list
+- Converting a list to and from a Array 
+

src/com/deepak/data/structures/Hashing/HashTable_vs_HashMap.md

@@ -1,4 +1,4 @@
-package com.deepak.LinkedList;
+package com.deepak.data.structures.LinkedList;
 
 public class SinglyLinkedList<E> {
 

src/com/deepak/data/structures/Hashing/Iterator_vs_Enumeration.md

@@ -0,0 +1,117 @@
+/**
+ * Data-Structures-And-Algorithms-in-Java
+ * ArrayBasedQueue.java
+ */
+package com.deepak.data.structures.Queue;
+
+import java.util.NoSuchElementException;
+
+/**
+ * Implementation of array based queue
+ * @author Deepak
+ */
+public class ArrayBasedQueue {
+
+	/**
+	 * Method to test queue implementation
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("Creating a new Array based queue.");
+		ArrayBasedQueue queue = new ArrayBasedQueue(10);
+		System.out.println("Size of Queue => " + queue.size());
+		System.out.println("Is Queue Empty => " + queue.isEmpty());
+		System.out.println("Inserting two items in Queue.");
+		queue.enqueue(10);
+		queue.enqueue(20);
+		System.out.println("After Insertion, Size of Queue => " + queue.size());
+		System.out.println("After Insertion, Is Queue Empty => " + queue.isEmpty());
+		System.out.println("Removing an item from Queue.");
+		queue.dequeue();
+		System.out.println("After Removal, Size of Queue => " + queue.size());
+		System.out.println("Top element on Queue => " + queue.peek());
+	}
+
+	/**
+	 * Array of objects
+	 */
+	private Object[] array;
+
+	/**
+	 * Size of queue
+	 */
+	int size = 0;
+
+	/**
+	 * Since it is a queue, we need track of both head and tail
+	 * Initial values to be 0
+	 */
+	int head = 0;
+	int tail = 0;
+
+	/**
+	 * Constructor to create new array based queue
+	 * @param capacity
+	 */
+	public ArrayBasedQueue(int capacity) {
+		array = new Object[capacity];
+	}
+
+	/**
+	 * Method to push a new item in queue
+	 * We will deal only with tail while adding new item
+	 * @param item
+	 */
+	public void enqueue(Object item) {
+		if (size == array.length) {
+			throw new IllegalStateException("Cannot add to full queue");
+		} 
+		array[tail] = item;
+		tail = (tail + 1) % array.length;
+		size++;
+	}
+
+	/**
+	 * Method to pop a item from queue
+	 * We will deal only with head while deleting a element
+	 * @return
+	 */
+	public Object dequeue() {
+		if (size == 0) {
+			throw new NoSuchElementException("Cannot remove from empty queue");
+		}
+		Object item = array[head];
+		array[head] = null;
+		head = (head + 1) % array.length;
+		size--;
+		return item;
+	}
+
+	/**
+	 * Method to check the top item in queue
+	 * @return
+	 */
+	public Object peek() {
+		if (size == 0) {
+			throw new NoSuchElementException("Cannot peek from empty queue");
+		}
+		return array[size - 1];
+	}
+
+	/**
+	 * Method to check size of queue
+	 * @return
+	 */
+	public int size() {
+		return size;
+	}
+
+	/**
+	 * Method to check if queue is empty
+	 * @return
+	 */
+	public boolean isEmpty() {
+		return size == 0;
+	}
+
+}