From 5b6005a930aab89040573d0eb06e8e26bf44e1d7 Mon Sep 17 00:00:00 2001
From: vinitachimalgi <62709854+vinitachimalgi@users.noreply.github.com>
Date: Tue, 8 Jun 2021 17:59:48 +0530
Subject: [PATCH 1/9] Add files via upload

---
 Dictionary-main (1).zip | Bin 0 -> 3788 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 Dictionary-main (1).zip

diff --git a/Dictionary-main (1).zip b/Dictionary-main (1).zip
new file mode 100644
index 0000000000000000000000000000000000000000..ab4988eae008edb0c36f993e30758caeebe6bec5
GIT binary patch
literal 3788
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
I0+ts40k74JOaK4?

literal 0
HcmV?d00001


From d45905ba560a1acb335199b05ce7f33cd62892ee Mon Sep 17 00:00:00 2001
From: vinitachimalgi <62709854+vinitachimalgi@users.noreply.github.com>
Date: Tue, 8 Jun 2021 18:08:02 +0530
Subject: [PATCH 2/9] Add files via upload

---
 README.md       |  56 +++++++++++++++++-
 Trees.java      | 154 ++++++++++++++++++++++++++++++++++++++++++++++++
 dictionary.java | 126 +++++++++++++++++++++++++++++++++++++++
 node.java       |  21 +++++++
 4 files changed, 354 insertions(+), 3 deletions(-)
 create mode 100644 Trees.java
 create mode 100644 dictionary.java
 create mode 100644 node.java

diff --git a/README.md b/README.md
index e674b94..7221eb4 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,55 @@
-# Buffer_2.0
-Buffer_2.0 repo to submit your projects to.Repository containing folder-wise code for all submissions to Buffer : A Project Series, conducted between April, 2021 - June, 2020.
+# Dictionary in Java
+The following project implements a dictionary using Java.
+Functionality available:
+1. Adding a word to dictionary along with its meaning
+2. updating a word's meaning
+3. Delete a word and its meaning
+4. search for a word's meaning
 
-Each folder should contain a separate README to describe the files and project objective
 
+Data Structure Used:
+The data structure used to add words is **Trie**. It is an efficient information reTRIEval data structure. The other option to realize a
+dictionary would be binary search trees, but a well balanced BST will need time proportional to M * log N, where M is maximum string
+length and N is number of keys in tree.Using Trie, we can search the key in O(M) time.
+
+Since a dictionary is often used to search meanings of words, we chose to favor time complexity instead of space and went ahead with
+tries. 
+
+Code Design Paramters:
+The trie node looks like this:
+```
+public class Node 
+{
+   char c;
+    boolean isWord;
+    Node[] children;
+    String meaning;
+
+    public Node(char c)
+    {
+      this.c=c;
+      isWord=false;
+      children=new Node[26];
+    }
+  public void setMeaning(String newMeaning)
+  {
+    this.meaning=newMeaning;
+  }
+
+}
+```
+Here, each node has 26 children! thats a lot of children for a node. And a lot of space. But this much space REALLY helps us reduce
+that searching time complexity from O(M * log N) down to  O(M) time, where M is length of word and N is number of keys. Plus, 
+Tries are more space efficient when they contain a large number of short keys, because nodes are shared between keys with common 
+initial subsequences. So, when it comes to handling large amounts of data, trie is our obvious winner.
+
+Outcomes:
+1. A new data structure - trie
+2. 
+
+
+
+References:
+Data Structures and Algorithms Made Easy in Java- Book
+https://thenextcode.wordpress.com/2015/04/12/trie-vs-bst-vs-hashtable/
+https://www.geeksforgeeks.org/trie-insert-and-search/
diff --git a/Trees.java b/Trees.java
new file mode 100644
index 0000000..7538d1c
--- /dev/null
+++ b/Trees.java
@@ -0,0 +1,154 @@
+package trees;
+import java.util.Scanner
+
+public class Trie {
+	private Node root;
+	
+	public Trie()
+	{
+		root=new Node('\0');
+	}	
+	
+	public Node getRoot() {
+		return root;
+	}
+	
+	public void insert(String word,String meaning)
+	{
+		Node curr=root;
+		for(int i=0;i<word.length();i++)
+		{
+		  char c=word.charAt(i);
+		  if(curr.children[c-'a']==null)
+		  {
+			  curr.children[c-'a']=new Node(c);
+		  }
+		  curr=curr.children[c-'a'];
+		}
+		curr.isWord=true;
+		curr.meaning=meaning;
+	}
+	public void search(String word)
+	{
+		boolean isPresent=((getNode(word)!=null)&&(getNode(word).isWord));
+		if(isPresent)
+		{
+			System.out.println(getNode(word).meaning);
+		}
+		else
+		{
+			System.out.println("Word doesn't exist");
+		}
+	}
+	private Node getNode(String word)
+	{
+		Node curr=root;
+		for(int i=0;i<word.length();i++)
+		{
+			char a=word.charAt(i);
+			if(curr.children[a-'a']==null)
+			{
+				return null;
+			}
+			curr=curr.children[a-'a'];
+		}
+		return curr;
+	}
+	
+		public void display(Node root,String word)
+		{
+			if(root == null)
+			{
+				return;
+			}
+			
+			if(root.isWord)
+			{
+				//word=word+root.c;
+				System.out.print(word+": "+root.meaning+",");
+				
+			}
+			
+			for(int i=0;i<26;i++)
+			{
+				if(root.children[i] != null)
+				{
+					word = word + root.children[i].c;
+					display(root.children[i], word);	// cat: animal, cdog: animal
+					word = word.substring(0, word.length()-1);
+				}
+
+			}
+
+			
+		}
+		
+		public Boolean delete(String word)
+		{
+			boolean isPresent = false;
+			isPresent = ((getNode(word)!=null)&&(getNode(word).isWord));
+			if(isPresent)
+			{
+				deleteWord(root, word, 0);
+				return true;
+			}
+			else
+			{
+				return false;
+			}
+		}
+		
+		   private Node deleteWord(Node node, String word, int i)
+		   {
+		        if (i == word.length())	//if end of word is reached
+		        {
+		            node.isWord = false;
+		        } 
+		        else 
+		        {
+		            int index = word.charAt(i) - 'a';
+		            node.children[index] = deleteWord(node.children[index], word, i + 1);
+		        }
+		        if (node.isWord) 
+		        {
+		            return node;
+		        }		        
+		        for(int n=0;n<26;n++)	//apple and apples 'e' has a node for 's' hence it'll return node otherwise would have returned null
+		        {
+		        	if(node.children[n] != null)
+		        	{
+		        			return node;
+		        	}
+		        }
+		        return null;
+		    }
+	
+	  public void update(Node root,String word)
+	  {
+		  boolean isPresent=((getNode(word)!=null)&&(getNode(word).isWord));
+		  if(isPresent)
+		  {
+			  String newMeaning;
+			  Scanner sc=new Scanner(System.in);
+			  System.out.println("Enter the updated meaning: ");
+			  newMeaning=sc.nextLine();
+			  getNode(word).setMeaning(newMeaning);
+			  System.out.println("Word updated");
+		  }
+		  else
+		  {
+			  System.out.println("Sorry you cannot update the word since the Word doesn't exist");
+		  }
+	  }
+	      
+	  public void displayWithPrefix(Node root,String prefix)
+	  {
+	       boolean isPresent=(getNode(word)!=null);
+	       if(isPresent)
+	       {
+	          Node last=getNode(prefix);
+		  display(last,prefix);
+	       }
+	   }
+}
+
diff --git a/dictionary.java b/dictionary.java
new file mode 100644
index 0000000..e59be58
--- /dev/null
+++ b/dictionary.java
@@ -0,0 +1,126 @@
+package logic;
+import trees.Trie;
+import trees.Node;
+
+import java.util.Scanner;
+
+public class Dictionary {
+	public static void main(String [] args)
+	{
+	        int choice = 0;
+		Trie Dictionary=new Trie();
+		Scanner sc=new Scanner(System.in);
+		int n = 0;
+		do
+		{
+			do
+			{
+				
+				System.out.println("Enter your choice");
+				System.out.println("1. INSERT A WORD");
+				System.out.println("2. SEARCH A WORD");
+				System.out.println("3. DELETE A WORD");
+				System.out.println("4. UPDATE MEANING OF A WORD");
+				System.out.println("5. DISPLAY WITH A PREFIX");
+				System.out.println("6. DISPLAY ALL THE WORDS");
+				System.out.println("0. EXIT");
+				System.out.println("Enter choice : \n");
+				if(sc.hasNextInt())
+				{
+				choice = sc.nextInt();
+				}
+				
+			}while(choice<0 || choice>6);
+			
+			switch(choice)
+			{
+				case 1 :
+							System.out.println("Enter the number of words you want to insert: ");
+							if(sc.hasNextInt())
+							{
+							n =sc.nextInt();
+							for(int i=0;i<n;i++)
+							{
+								System.out.println("Enter the word: ");
+								String word;
+								word=sc.next();
+								System.out.println("Enter the meaning: ");
+								String meaning;
+								meaning=sc.next();
+								Dictionary.insert(word,meaning);
+							  }
+							}
+							  break;
+							 
+				case 2 : 
+					
+						   System.out.println("Enter the word you want to search: ");
+						   String searchWord;
+						   searchWord=sc.next();
+						   Boolean search = false;
+						   search = Dictionary.search(searchWord);
+						   if(!search)
+						   {
+							   System.out.println("Word doesn't exist");
+						   }
+						   break;
+				
+				case 3 : 
+						   System.out.println("Enter the word you want to delete: ");
+						   String deleteWord;
+						   deleteWord=sc.next();
+						   Boolean delete = false;
+						   delete = Dictionary.delete(deleteWord);
+						   if(delete)
+						   {
+							   System.out.println("Word deleted");
+						   }
+						   else
+						   {
+							   System.out.println("Word doesn't exist");
+						   }	
+						   break;
+						   
+				case 4 :
+						   String updateWord;
+						   System.out.println("Enter the word to be updated ");
+						   updateWord = sc.next();
+						   Dictionary.update(Dictionary.getRoot(), updateWord);
+						   break;
+					
+				case 5 : 
+						   String prefixWord;
+						   System.out.println("Enter the prefix :");
+						   prefixWord = sc.next();
+						   Dictionary.displayWithPrefix(Dictionary.getRoot(), prefixWord);
+						   break;
+				
+				case 6 : 
+						   String word=" ";
+						   if(Dictionary.getRoot() == null)
+						   {
+							   Dictionary.display(Dictionary.getRoot(),word);
+						   }
+						   else
+						   {
+							   System.out.println("No words in the dictionary");
+						   }
+							   break;
+							   
+				case 0 :
+							break;
+						   
+				default :
+							System.out.println("Invalid input");
+							break;
+						 
+			}
+			
+		}while(choice != 0);
+	   	   
+	   sc.close();
+	   
+	}
+	}
+
+}
diff --git a/node.java b/node.java
new file mode 100644
index 0000000..36cdac0
--- /dev/null
+++ b/node.java
@@ -0,0 +1,21 @@
+package trees;
+
+
+public class Node {
+	 char c;
+		boolean isWord;
+		Node[] children;
+		String meaning;
+		
+		public Node(char c)
+		{
+			this.c=c;
+			isWord=false;
+			children=new Node[26];
+		}
+	public void setMeaning(String newMeaning)
+	{
+		this.meaning=newMeaning;
+	}
+
+}

From 7b2888eae4e71e644dff9e1717a111c3f7b88055 Mon Sep 17 00:00:00 2001
From: vinitachimalgi <62709854+vinitachimalgi@users.noreply.github.com>
Date: Tue, 8 Jun 2021 18:09:01 +0530
Subject: [PATCH 3/9] Delete Dictionary-main (1).zip

---
 Dictionary-main (1).zip | Bin 3788 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 Dictionary-main (1).zip

diff --git a/Dictionary-main (1).zip b/Dictionary-main (1).zip
deleted file mode 100644
index ab4988eae008edb0c36f993e30758caeebe6bec5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3788
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
I0+ts40k74JOaK4?


From 37da1b74578e80d92467dc4bebf729930be10da6 Mon Sep 17 00:00:00 2001
From: vinitachimalgi <62709854+vinitachimalgi@users.noreply.github.com>
Date: Tue, 8 Jun 2021 20:53:33 +0530
Subject: [PATCH 4/9] Delete Trees.java

---
 Trees.java | 154 -----------------------------------------------------
 1 file changed, 154 deletions(-)
 delete mode 100644 Trees.java

diff --git a/Trees.java b/Trees.java
deleted file mode 100644
index 7538d1c..0000000
--- a/Trees.java
+++ /dev/null
@@ -1,154 +0,0 @@
-package trees;
-import java.util.Scanner
-
-public class Trie {
-	private Node root;
-	
-	public Trie()
-	{
-		root=new Node('\0');
-	}	
-	
-	public Node getRoot() {
-		return root;
-	}
-	
-	public void insert(String word,String meaning)
-	{
-		Node curr=root;
-		for(int i=0;i<word.length();i++)
-		{
-		  char c=word.charAt(i);
-		  if(curr.children[c-'a']==null)
-		  {
-			  curr.children[c-'a']=new Node(c);
-		  }
-		  curr=curr.children[c-'a'];
-		}
-		curr.isWord=true;
-		curr.meaning=meaning;
-	}
-	public void search(String word)
-	{
-		boolean isPresent=((getNode(word)!=null)&&(getNode(word).isWord));
-		if(isPresent)
-		{
-			System.out.println(getNode(word).meaning);
-		}
-		else
-		{
-			System.out.println("Word doesn't exist");
-		}
-	}
-	private Node getNode(String word)
-	{
-		Node curr=root;
-		for(int i=0;i<word.length();i++)
-		{
-			char a=word.charAt(i);
-			if(curr.children[a-'a']==null)
-			{
-				return null;
-			}
-			curr=curr.children[a-'a'];
-		}
-		return curr;
-	}
-	
-		public void display(Node root,String word)
-		{
-			if(root == null)
-			{
-				return;
-			}
-			
-			if(root.isWord)
-			{
-				//word=word+root.c;
-				System.out.print(word+": "+root.meaning+",");
-				
-			}
-			
-			for(int i=0;i<26;i++)
-			{
-				if(root.children[i] != null)
-				{
-					word = word + root.children[i].c;
-					display(root.children[i], word);	// cat: animal, cdog: animal
-					word = word.substring(0, word.length()-1);
-				}
-
-			}
-
-			
-		}
-		
-		public Boolean delete(String word)
-		{
-			boolean isPresent = false;
-			isPresent = ((getNode(word)!=null)&&(getNode(word).isWord));
-			if(isPresent)
-			{
-				deleteWord(root, word, 0);
-				return true;
-			}
-			else
-			{
-				return false;
-			}
-		}
-		
-		   private Node deleteWord(Node node, String word, int i)
-		   {
-		        if (i == word.length())	//if end of word is reached
-		        {
-		            node.isWord = false;
-		        } 
-		        else 
-		        {
-		            int index = word.charAt(i) - 'a';
-		            node.children[index] = deleteWord(node.children[index], word, i + 1);
-		        }
-		        if (node.isWord) 
-		        {
-		            return node;
-		        }		        
-		        for(int n=0;n<26;n++)	//apple and apples 'e' has a node for 's' hence it'll return node otherwise would have returned null
-		        {
-		        	if(node.children[n] != null)
-		        	{
-		        			return node;
-		        	}
-		        }
-		        return null;
-		    }
-	
-	  public void update(Node root,String word)
-	  {
-		  boolean isPresent=((getNode(word)!=null)&&(getNode(word).isWord));
-		  if(isPresent)
-		  {
-			  String newMeaning;
-			  Scanner sc=new Scanner(System.in);
-			  System.out.println("Enter the updated meaning: ");
-			  newMeaning=sc.nextLine();
-			  getNode(word).setMeaning(newMeaning);
-			  System.out.println("Word updated");
-		  }
-		  else
-		  {
-			  System.out.println("Sorry you cannot update the word since the Word doesn't exist");
-		  }
-	  }
-	      
-	  public void displayWithPrefix(Node root,String prefix)
-	  {
-	       boolean isPresent=(getNode(word)!=null);
-	       if(isPresent)
-	       {
-	          Node last=getNode(prefix);
-		  display(last,prefix);
-	       }
-	   }
-}
-

From 7ef8a2d689057f62dd99d08c26b15d7690528ea2 Mon Sep 17 00:00:00 2001
From: vinitachimalgi <62709854+vinitachimalgi@users.noreply.github.com>
Date: Tue, 8 Jun 2021 20:53:47 +0530
Subject: [PATCH 5/9] Delete dictionary.java

---
 dictionary.java | 126 ------------------------------------------------
 1 file changed, 126 deletions(-)
 delete mode 100644 dictionary.java

diff --git a/dictionary.java b/dictionary.java
deleted file mode 100644
index e59be58..0000000
--- a/dictionary.java
+++ /dev/null
@@ -1,126 +0,0 @@
-package logic;
-import trees.Trie;
-import trees.Node;
-
-import java.util.Scanner;
-
-public class Dictionary {
-	public static void main(String [] args)
-	{
-	        int choice = 0;
-		Trie Dictionary=new Trie();
-		Scanner sc=new Scanner(System.in);
-		int n = 0;
-		do
-		{
-			do
-			{
-				
-				System.out.println("Enter your choice");
-				System.out.println("1. INSERT A WORD");
-				System.out.println("2. SEARCH A WORD");
-				System.out.println("3. DELETE A WORD");
-				System.out.println("4. UPDATE MEANING OF A WORD");
-				System.out.println("5. DISPLAY WITH A PREFIX");
-				System.out.println("6. DISPLAY ALL THE WORDS");
-				System.out.println("0. EXIT");
-				System.out.println("Enter choice : \n");
-				if(sc.hasNextInt())
-				{
-				choice = sc.nextInt();
-				}
-				
-			}while(choice<0 || choice>6);
-			
-			switch(choice)
-			{
-				case 1 :
-							System.out.println("Enter the number of words you want to insert: ");
-							if(sc.hasNextInt())
-							{
-							n =sc.nextInt();
-							for(int i=0;i<n;i++)
-							{
-								System.out.println("Enter the word: ");
-								String word;
-								word=sc.next();
-								System.out.println("Enter the meaning: ");
-								String meaning;
-								meaning=sc.next();
-								Dictionary.insert(word,meaning);
-							  }
-							}
-							  break;
-							 
-				case 2 : 
-					
-						   System.out.println("Enter the word you want to search: ");
-						   String searchWord;
-						   searchWord=sc.next();
-						   Boolean search = false;
-						   search = Dictionary.search(searchWord);
-						   if(!search)
-						   {
-							   System.out.println("Word doesn't exist");
-						   }
-						   break;
-				
-				case 3 : 
-						   System.out.println("Enter the word you want to delete: ");
-						   String deleteWord;
-						   deleteWord=sc.next();
-						   Boolean delete = false;
-						   delete = Dictionary.delete(deleteWord);
-						   if(delete)
-						   {
-							   System.out.println("Word deleted");
-						   }
-						   else
-						   {
-							   System.out.println("Word doesn't exist");
-						   }	
-						   break;
-						   
-				case 4 :
-						   String updateWord;
-						   System.out.println("Enter the word to be updated ");
-						   updateWord = sc.next();
-						   Dictionary.update(Dictionary.getRoot(), updateWord);
-						   break;
-					
-				case 5 : 
-						   String prefixWord;
-						   System.out.println("Enter the prefix :");
-						   prefixWord = sc.next();
-						   Dictionary.displayWithPrefix(Dictionary.getRoot(), prefixWord);
-						   break;
-				
-				case 6 : 
-						   String word=" ";
-						   if(Dictionary.getRoot() == null)
-						   {
-							   Dictionary.display(Dictionary.getRoot(),word);
-						   }
-						   else
-						   {
-							   System.out.println("No words in the dictionary");
-						   }
-							   break;
-							   
-				case 0 :
-							break;
-						   
-				default :
-							System.out.println("Invalid input");
-							break;
-						 
-			}
-			
-		}while(choice != 0);
-	   	   
-	   sc.close();
-	   
-	}
-	}
-
-}

From 39dae89704ce8eb25a34d797e3030acda9586475 Mon Sep 17 00:00:00 2001
From: vinitachimalgi <62709854+vinitachimalgi@users.noreply.github.com>
Date: Tue, 8 Jun 2021 20:54:01 +0530
Subject: [PATCH 6/9] Delete node.java

---
 node.java | 21 ---------------------
 1 file changed, 21 deletions(-)
 delete mode 100644 node.java

diff --git a/node.java b/node.java
deleted file mode 100644
index 36cdac0..0000000
--- a/node.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package trees;
-
-
-public class Node {
-	 char c;
-		boolean isWord;
-		Node[] children;
-		String meaning;
-		
-		public Node(char c)
-		{
-			this.c=c;
-			isWord=false;
-			children=new Node[26];
-		}
-	public void setMeaning(String newMeaning)
-	{
-		this.meaning=newMeaning;
-	}
-
-}

From 573dbfaa125c6e467a5cc5c2a17e04675a95778e Mon Sep 17 00:00:00 2001
From: vinitachimalgi <62709854+vinitachimalgi@users.noreply.github.com>
Date: Tue, 8 Jun 2021 20:56:34 +0530
Subject: [PATCH 7/9] Add files via upload

---
 Dictionary.java | 146 ++++++++++++++++++++++++++++++++++++++++++
 Node.java       |  22 +++++++
 Trie.java       | 164 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 332 insertions(+)
 create mode 100644 Dictionary.java
 create mode 100644 Node.java
 create mode 100644 Trie.java

diff --git a/Dictionary.java b/Dictionary.java
new file mode 100644
index 0000000..8ec0563
--- /dev/null
+++ b/Dictionary.java
@@ -0,0 +1,146 @@
+package logic;
+
+
+import java.util.Scanner;
+
+import logic.Trie;
+
+public class Dictionary
+{
+	public static void main(String [] args) 
+	{
+	   
+		int choice = 0;
+		Trie Dictionary=new Trie();
+		Scanner sc=new Scanner(System.in);
+		int n = 0;
+		
+		do
+		{
+			
+			do
+			{
+				
+				System.out.println("\n\tM E N U");
+				System.out.println("*******************************");
+				System.out.println("1. INSERT A WORD");
+				System.out.println("2. SEARCH A WORD");
+				System.out.println("3. DELETE A WORD");
+				System.out.println("4. UPDATE MEANING OF A WORD");
+				System.out.println("5. DISPLAY WITH A PREFIX");
+				System.out.println("6. DISPLAY ALL THE WORDS");
+				System.out.println("0. EXIT");
+				System.out.println("*******************************");
+				System.out.print("Enter choice : ");
+				if(sc.hasNextInt())
+				{
+				choice = sc.nextInt();
+				}
+				
+			}while(choice<0 || choice>6);
+			
+			switch(choice)
+			{
+				case 1 :
+							System.out.print("\n Enter the number of words you want to insert : ");
+							
+							n =sc.nextInt();
+							for(int i=0;i<n;i++)
+							{
+								System.out.print("\n Enter the word: ");
+								String word;
+								word=sc.next();
+								System.out.print("\n Enter the meaning: ");
+								String meaning;
+								meaning=sc.next();
+								Dictionary.insert(word,meaning);
+								System.out.println("\n-----------------------------");
+							  }
+							
+							  break;
+							 
+				case 2 : 
+					
+						   System.out.print("\n Enter the word you want to search : ");
+						   String searchWord;
+						   searchWord=sc.next();
+						   Boolean search = false;
+						   search = Dictionary.search(searchWord);
+						   if(!search)
+						   {
+							   System.out.println("\n Word doesn't exist");
+						   }
+						   System.out.println("\n-----------------------------");
+						   break;
+				
+				case 3 : 
+						   System.out.print("\n Enter the word you want to delete: ");
+						   String deleteWord;
+						   deleteWord=sc.next();
+						   Boolean delete = false;
+						   delete = Dictionary.delete(deleteWord);
+						   if(delete)
+						   {
+							   System.out.println(" Word deleted successfully!!");
+						   }
+						   else
+						   {
+							   System.out.println("\n Word doesn't exist!");
+						   }	
+						   System.out.println("\n-----------------------------");
+						   break;
+						   
+				case 4 :
+						   String updateWord;
+						   System.out.print("\n Enter the word to be updated : ");
+						   updateWord = sc.next();
+						   Dictionary.update(Dictionary.getRoot(), updateWord);
+						   System.out.println("\n-----------------------------");
+						   break;
+					
+				case 5 : 
+						   String prefixWord;
+						   if(Dictionary.getRoot() != null)
+						   {
+							   System.out.println("\n Enter the prefix :");
+							   prefixWord = sc.next();
+							   Dictionary.displayWithPrefix(Dictionary.getRoot(), prefixWord);
+						   }
+						   else
+						   {
+							   System.out.println("\n Dictionary is empty!");
+						   }
+						   System.out.println("\n-----------------------------");
+						   break;
+				
+				case 6 : 
+						   String word=" ";
+						   if(Dictionary.getRoot() != null)
+						   {
+							   Dictionary.display(Dictionary.getRoot(),word);
+						   }
+						   else
+						   {
+							   System.out.println(" No words in the dictionary");
+						   }
+						   System.out.println("\n-----------------------------");
+						   break;
+							   
+				case 0 :
+							break;
+						   
+				default :
+							System.out.println("Invalid input");
+							System.out.println("\n-----------------------------");
+							break;
+						 
+			}
+			
+		}while(choice != 0);
+	   	   
+	   sc.close();
+	   
+	}	
+	
+}
+
diff --git a/Node.java b/Node.java
new file mode 100644
index 0000000..c962998
--- /dev/null
+++ b/Node.java
@@ -0,0 +1,22 @@
+package logic;
+
+public class Node 
+{
+		 	char c;
+			boolean isWord = false;
+			Node[] children;
+			String meaning;
+			
+			public Node(char c)
+			{
+				this.c=c;
+				isWord=false;
+				children = new Node[26];
+			}
+			
+			public void setMeaning(String newMeaning)
+			{
+				this.meaning=newMeaning;
+			}
+}
+
diff --git a/Trie.java b/Trie.java
new file mode 100644
index 0000000..ca856f4
--- /dev/null
+++ b/Trie.java
@@ -0,0 +1,164 @@
+package logic;
+import java.util.Scanner;
+
+public class Trie 
+{
+		private Node root;
+
+		public Trie()
+		{
+			root=new Node('\0');
+		}
+		
+		public Node getRoot() {
+			return root;
+		}
+
+		public void insert(String word,String meaning)
+		{
+			Node curr=root;
+			for(int i=0;i<word.length();i++)
+			{
+			  char ch=word.charAt(i);
+			  if(curr.children[ch-'a']==null)
+			  {
+				  curr.children[ch-'a']=new Node(ch);
+			  }
+			  curr=curr.children[ch-'a'];
+			}
+			curr.isWord=true;
+			curr.meaning=meaning;
+		}
+		
+		public Boolean search(String word)
+		{
+			boolean isPresent= false;
+			isPresent = ((getNode(word)!=null)&&(getNode(word).isWord));
+			if(isPresent)
+			{
+				System.out.println("\n Word found!!\n");
+				System.out.print(" Meaning of " + word + " is : ");
+				System.out.println(getNode(word).meaning);
+			}
+			return isPresent;
+		}
+		
+
+		public void display(Node root,String word)
+		{
+			if(root == null)
+			{
+				return;
+			}
+			
+			if(root.isWord)
+			{
+				//word=word+root.c;
+				System.out.println("\n" + word+" : "+root.meaning);
+				
+			}
+			
+			for(int i=0;i<26;i++)
+			{
+				if(root.children[i] != null)
+				{
+					word = word + root.children[i].c;
+					display(root.children[i], word);	
+					word = word.substring(0, word.length()-1);
+				}
+
+			}
+
+			
+		}
+		
+		private Node getNode(String word)
+		{
+			Node curr=root;
+			for(int i=0;i<word.length();i++)
+			{
+				char a=word.charAt(i);
+				if(curr.children[a-'a']==null)
+				{
+					return null;
+				}
+				curr=curr.children[a-'a'];
+			}
+			return curr;
+		}
+		
+		public Boolean delete(String word)
+		{
+			boolean isPresent = false;
+			isPresent = ((getNode(word)!=null)&&(getNode(word).isWord));
+			if(isPresent)
+			{
+				deleteWord(root, word, 0);
+				return true;
+			}
+			else
+			{
+				return false;
+			}
+		}
+		
+		   private Node deleteWord(Node node, String word, int i)
+		   {
+		        if (i == word.length())	//if end of word is reached
+		        {
+		            node.isWord = false;
+		        } 
+		        else 
+		        {
+		            int index = word.charAt(i) - 'a';
+		            node.children[index] = deleteWord(node.children[index], word, i + 1);
+		        }
+		        if (node.isWord) 
+		        {
+		            return node;
+		        }		        
+		        for(int n=0;n<26;n++)	
+		        {
+		        	if(node.children[n] != null)
+		        	{
+		        			return node;
+		        	}
+		        }
+		        return null;
+		    }
+		   
+		  	  
+
+		   	  public void update(Node root,String word)
+		   	  {
+		   		  boolean isPresent=((getNode(word)!=null)&&(getNode(word).isWord));
+		   		  if(isPresent)
+		   		  {
+		   			  String newMeaning;
+		   			  Scanner sc = new Scanner(System.in);
+		   			  System.out.print("\n Enter the updated meaning : ");
+		   			  newMeaning=sc.nextLine();
+		   			  getNode(word).setMeaning(newMeaning);
+		   			  System.out.println(" Word updated");
+		   			  //sc.close();
+		   		  }
+		   		  else
+		   		  {
+		   			  System.out.println(" Sorry you cannot update the word since the word doesn't exist");
+		   		  }
+		   		  
+		   	  }
+		   	      
+		   	  public void displayWithPrefix(Node root,String prefix)
+		   	  {
+		   	       boolean isPresent=(getNode(prefix)!=null);
+		   	       if(isPresent)
+		   	       {
+		   	          Node last=getNode(prefix);
+		   	          display(last,prefix);
+		   	       }
+		   	   }
+		   
+
+}
+

From 664f3a47008709db38d239488dd2c1ba8d6fc03e Mon Sep 17 00:00:00 2001
From: vinitachimalgi <62709854+vinitachimalgi@users.noreply.github.com>
Date: Tue, 8 Jun 2021 20:58:40 +0530
Subject: [PATCH 8/9] Delete README.md

---
 README.md | 55 -------------------------------------------------------
 1 file changed, 55 deletions(-)
 delete mode 100644 README.md

diff --git a/README.md b/README.md
deleted file mode 100644
index 7221eb4..0000000
--- a/README.md
+++ /dev/null
@@ -1,55 +0,0 @@
-# Dictionary in Java
-The following project implements a dictionary using Java.
-Functionality available:
-1. Adding a word to dictionary along with its meaning
-2. updating a word's meaning
-3. Delete a word and its meaning
-4. search for a word's meaning
-
-
-Data Structure Used:
-The data structure used to add words is **Trie**. It is an efficient information reTRIEval data structure. The other option to realize a
-dictionary would be binary search trees, but a well balanced BST will need time proportional to M * log N, where M is maximum string
-length and N is number of keys in tree.Using Trie, we can search the key in O(M) time.
-
-Since a dictionary is often used to search meanings of words, we chose to favor time complexity instead of space and went ahead with
-tries. 
-
-Code Design Paramters:
-The trie node looks like this:
-```
-public class Node 
-{
-   char c;
-    boolean isWord;
-    Node[] children;
-    String meaning;
-
-    public Node(char c)
-    {
-      this.c=c;
-      isWord=false;
-      children=new Node[26];
-    }
-  public void setMeaning(String newMeaning)
-  {
-    this.meaning=newMeaning;
-  }
-
-}
-```
-Here, each node has 26 children! thats a lot of children for a node. And a lot of space. But this much space REALLY helps us reduce
-that searching time complexity from O(M * log N) down to  O(M) time, where M is length of word and N is number of keys. Plus, 
-Tries are more space efficient when they contain a large number of short keys, because nodes are shared between keys with common 
-initial subsequences. So, when it comes to handling large amounts of data, trie is our obvious winner.
-
-Outcomes:
-1. A new data structure - trie
-2. 
-
-
-
-References:
-Data Structures and Algorithms Made Easy in Java- Book
-https://thenextcode.wordpress.com/2015/04/12/trie-vs-bst-vs-hashtable/
-https://www.geeksforgeeks.org/trie-insert-and-search/

From b868dbbc6a37697c123abbbae278b946078dcf05 Mon Sep 17 00:00:00 2001
From: vinitachimalgi <62709854+vinitachimalgi@users.noreply.github.com>
Date: Tue, 8 Jun 2021 21:00:48 +0530
Subject: [PATCH 9/9] Add files via upload

---
 README.md | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 README.md

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..7490f38
--- /dev/null
+++ b/README.md
@@ -0,0 +1,69 @@
+# Dictionary in Java
+The following project implements a dictionary using Java.
+Functionality available:
+1. Adding a word to dictionary along with its meaning
+2. updating a word's meaning
+3. Delete a word and its meaning
+4. search for a word's meaning
+
+
+### **Data Structure Used:**
+
+The data structure used to add words is **Trie**. Also known as **Prefix Trees**. Tries have the unique feature that the time to insert or to delete or find is almost identical because the code paths followed are most identical.  It is an efficient information reTRIEval data structure.
+There are other alternative data structures that can be used to build and perform these operations on a dictionary. The most significant one being BST.
+We used Trie over BST for the following reasons:
+* In trie looking up a key of length m takes worst case O(m) time. On the other hand a well balanced BST performs O((logn)) comparisons of keys where n is the number of elements in the tree.Hence is the worst case a BST will need time proportional to M * log N, where M is maximum string
+length and N is number of keys in tree. Using Trie, we can search the key in O(M) time.
+* Another huge advantage of Trie over the other considerable Data Structure HashTable is printing out all the words in alphabetical order.
+* An efficient prefix search is also possible through Tries.
+Since a dictionary is often used to search meanings of words, we chose to favor time complexity instead of space and went ahead with
+tries. 
+
+### **Code Design Parameters:**
+
+The trie node looks like this:
+```
+public class Node 
+{
+   char c;
+    boolean isWord;
+    Node[] children;
+    String meaning;
+
+    public Node(char c)
+    {
+      this.c=c;
+      isWord=false;
+      children=new Node[26];
+    }
+  public void setMeaning(String newMeaning)
+  {
+    this.meaning=newMeaning;
+  }
+
+}
+```
+Here, each node has 26 children! thats a lot of children for a node. And a lot of space. But this much space REALLY helps us reduce
+that searching time complexity from O(M * log N) down to  O(M) time, where M is length of word and N is number of keys. Plus, 
+Tries are more space efficient when they contain a large number of short keys, because nodes are shared between keys with common 
+initial subsequences. So, when it comes to handling large amounts of data, trie is our obvious winner.
+
+### **Outcomes:**
+
+1. A new Data Structure- Trie - As students who have predominantly coded in C throughout the first two years of college, picking up a new language and a data structure that we weren't acquainted with was exciting and challenging. At a glance while Trie appeared to be a way more complex tree than the other trees, as we digged deeper we discovered the varied functionality of this data structure and why it is used more so for projects where large datasets are used. It makes their access and serach easier.  
+2. Understanding time and space complexitites better-  We made a head to head comparsion of time complexities of varied data structures that could perform the same operations and then made an informed choice based on our observation. This has helped us greatly in understanding the paramount importance of time complexity in projects like these. The project has made us more intuitive and familair with the role of space and time complexity.
+3. Working in a team along with fellow classmated beyond the classroom also has been a great experience. 
+
+### **What's next for the project**
+
+We aim to improvise on the code and make in user friendly by incorporating Java Swing to enhance the real time effect. We also mean to import datasets using SQL and make the dictionary user-ready
+
+### **References:**
+
+1. Data Structures and Algorithms Made Easy in Java- Book
+
+2. https://thenextcode.wordpress.com/2015/04/12/trie-vs-bst-vs-hashtable/
+3. https://www.geeksforgeeks.org/trie-insert-and-search/
+4. https://www.baeldung.com/trie-java#:~:text=In%20a%20trie%2C%20every%20node,of%20the%20trie%20as%20well
+5. https://gist.github.com/prettymuchbryce/3719435/868ae3231e98b3bde667a9e899157e20dd58c366
+6. https://www.geeksforgeeks.org/implement-a-dictionary-using-trie/