From 2a9ed0b506af74f26af8815d335385bfea188e83 Mon Sep 17 00:00:00 2001 From: ashutoshsingh05 <201851029@iiitvadodara.ac.in> Date: Wed, 17 Apr 2019 11:01:52 +0530 Subject: [PATCH] Added basic data structures --- .../BoundsException.java | 6 + .../ArrayListImplementation/Driver.java | 49 ++++++ OrderedList/ArrayListImplementation/List.java | 8 + .../ArrayListImplementation/OrderedList.java | 82 ++++++++++ .../BoundsException.java | 6 + .../LinearListImplementation/Driver.java | 48 ++++++ .../LinearListImplementation/LinkedList.java | 8 + .../LinearListImplementation/ListObject.java | 14 ++ .../LinearListImplementation/OrderedList.java | 75 +++++++++ .../BoundsException.java | 8 + Queue/ArrayList Implementation/Driver.java | 45 +++++ Queue/ArrayList Implementation/List.java | 7 + Queue/ArrayList Implementation/QueueAL.java | 55 +++++++ .../BoundsException.java | 8 + Queue/LinkedList Implementation/Driver.java | 45 +++++ .../LinkedList Implementation/ListObject.java | 14 ++ Queue/LinkedList Implementation/Queue.java | 7 + Queue/LinkedList Implementation/QueueLL.java | 61 +++++++ .../BoundsException.java | 8 + Stack/ArrayList Implementation/Driver.java | 42 +++++ Stack/ArrayList Implementation/List.java | 7 + Stack/ArrayList Implementation/Stack.java | 48 ++++++ .../BoundsException.java | 8 + Stack/LinearList Implementation/Driver.java | 42 +++++ .../LinearList Implementation/LinkedList.java | 7 + .../LinearList Implementation/ListObject.java | 14 ++ Stack/LinearList Implementation/StackLL.java | 56 +++++++ UnorderedList/ArrayList/ArrayList.java | 54 ++++++ UnorderedList/ArrayList/BoundsException.java | 8 + UnorderedList/ArrayList/Driver.java | 49 ++++++ UnorderedList/ArrayList/List.java | 7 + UnorderedList/LinearList/BoundsException.java | 8 + UnorderedList/LinearList/Driver.java | 66 ++++++++ UnorderedList/LinearList/LinearList.java | 154 ++++++++++++++++++ UnorderedList/LinearList/List.java | 19 +++ UnorderedList/LinearList/ListObject.java | 14 ++ 36 files changed, 1157 insertions(+) create mode 100644 OrderedList/ArrayListImplementation/BoundsException.java create mode 100644 OrderedList/ArrayListImplementation/Driver.java create mode 100644 OrderedList/ArrayListImplementation/List.java create mode 100644 OrderedList/ArrayListImplementation/OrderedList.java create mode 100644 OrderedList/LinearListImplementation/BoundsException.java create mode 100644 OrderedList/LinearListImplementation/Driver.java create mode 100644 OrderedList/LinearListImplementation/LinkedList.java create mode 100644 OrderedList/LinearListImplementation/ListObject.java create mode 100644 OrderedList/LinearListImplementation/OrderedList.java create mode 100644 Queue/ArrayList Implementation/BoundsException.java create mode 100644 Queue/ArrayList Implementation/Driver.java create mode 100644 Queue/ArrayList Implementation/List.java create mode 100644 Queue/ArrayList Implementation/QueueAL.java create mode 100644 Queue/LinkedList Implementation/BoundsException.java create mode 100644 Queue/LinkedList Implementation/Driver.java create mode 100644 Queue/LinkedList Implementation/ListObject.java create mode 100644 Queue/LinkedList Implementation/Queue.java create mode 100644 Queue/LinkedList Implementation/QueueLL.java create mode 100644 Stack/ArrayList Implementation/BoundsException.java create mode 100644 Stack/ArrayList Implementation/Driver.java create mode 100644 Stack/ArrayList Implementation/List.java create mode 100644 Stack/ArrayList Implementation/Stack.java create mode 100644 Stack/LinearList Implementation/BoundsException.java create mode 100644 Stack/LinearList Implementation/Driver.java create mode 100644 Stack/LinearList Implementation/LinkedList.java create mode 100644 Stack/LinearList Implementation/ListObject.java create mode 100644 Stack/LinearList Implementation/StackLL.java create mode 100644 UnorderedList/ArrayList/ArrayList.java create mode 100644 UnorderedList/ArrayList/BoundsException.java create mode 100644 UnorderedList/ArrayList/Driver.java create mode 100644 UnorderedList/ArrayList/List.java create mode 100644 UnorderedList/LinearList/BoundsException.java create mode 100644 UnorderedList/LinearList/Driver.java create mode 100644 UnorderedList/LinearList/LinearList.java create mode 100644 UnorderedList/LinearList/List.java create mode 100644 UnorderedList/LinearList/ListObject.java diff --git a/OrderedList/ArrayListImplementation/BoundsException.java b/OrderedList/ArrayListImplementation/BoundsException.java new file mode 100644 index 0000000..e49db5e --- /dev/null +++ b/OrderedList/ArrayListImplementation/BoundsException.java @@ -0,0 +1,6 @@ +class BoundsException extends Exception { + void Error() { + printStackTrace(); + System.out.println("Out of bounds exception occured!"); + } +} \ No newline at end of file diff --git a/OrderedList/ArrayListImplementation/Driver.java b/OrderedList/ArrayListImplementation/Driver.java new file mode 100644 index 0000000..8a7ae30 --- /dev/null +++ b/OrderedList/ArrayListImplementation/Driver.java @@ -0,0 +1,49 @@ +import java.util.Scanner; + +class Driver { + public static void main(String arg[]) { + Scanner in = new Scanner(System.in); + OrderedList dataStructure = new OrderedList(); + int choice, userInput; + Boolean Continue = true; + System.out.println("MENU DRIVEN ORDEREDLIST"); + while (Continue) { + System.out.print( + "\n1) Enter new Data Element\n2) Search for an Element\n3) Traverse the whole array\n4) Find element by position\n5) Check if array is empty\n6) Exit\n\n Your CHOICE: "); + choice = in.nextInt(); + switch (choice) { + case 1: + System.out.print("Enter element to add: "); + userInput = in.nextInt(); + dataStructure.add(userInput); + break; + case 2: + System.out.print("Enter element to Search: "); + userInput = in.nextInt(); + if (!dataStructure.search(userInput)) + System.out.println("Element " + userInput + " not found!"); + break; + case 3: + dataStructure.traverse(); + break; + case 4: + System.out.print("Enter index to get Element: "); + userInput = in.nextInt(); + System.out.println("Element at index " + userInput + " is " + dataStructure.getElementAt(userInput)); + break; + case 5: + if (dataStructure.isEmpty()) + System.out.println("DataStructure is empty!"); + else + System.out.println("DataStructure is not empty!"); + break; + case 6: + Continue = false; + break; + default: + System.out.println("Invalid Value! Enter 6 to exit!!"); + } + } + in.close(); + } +} \ No newline at end of file diff --git a/OrderedList/ArrayListImplementation/List.java b/OrderedList/ArrayListImplementation/List.java new file mode 100644 index 0000000..93a1c4c --- /dev/null +++ b/OrderedList/ArrayListImplementation/List.java @@ -0,0 +1,8 @@ +interface List{ + Integer getElementAt(Integer position); + void add(Integer element); + void traverse(); + Boolean isEmpty(); + Boolean search(Integer element); + Integer getSize(); +} \ No newline at end of file diff --git a/OrderedList/ArrayListImplementation/OrderedList.java b/OrderedList/ArrayListImplementation/OrderedList.java new file mode 100644 index 0000000..5d30664 --- /dev/null +++ b/OrderedList/ArrayListImplementation/OrderedList.java @@ -0,0 +1,82 @@ +public class OrderedList implements List { + Integer arr[], size, initialSize; + + OrderedList() { + initialSize = 5; + size = 0; + arr = new Integer[initialSize]; + } + + public void add(Integer element) { + if (size == initialSize) { + Integer tempArr[] = new Integer[initialSize *= 2]; + for (int i = 0; i < size; i++) { + tempArr[i] = arr[i]; + } + arr = tempArr; + } + if (size == 0) { + arr[size] = element; + } else { + for (int i = size; i >= 0; i--) { + if (arr[i - 1] > element) { + arr[i] = arr[i - 1]; + if (i - 2 < 0) { + arr[i - 1] = element; + break; + } + } else { + arr[i] = element; + break; + } + } + } + size++; + traverse(); + } + + public Boolean isEmpty() { + return size == 0 ? true : false; + } + + public void traverse() { + System.out.print("Datastructure contents: "); + for (Integer i = 0; i < size; i++) { + System.out.print(arr[i] + " "); + } + System.out.println(""); + } + + public Boolean search(Integer element) { + Integer low = 0, high = size - 1, mid; + Boolean elementFound = false; + while (low <= high) { + mid = (low + high) / 2; + if (arr[mid] == element) { + System.out.println("Found " + element + " at index " + mid); + elementFound = true; + break; + } else if (arr[mid] > element) { + high = mid-1; + } else { + low = mid+1; + } + } + return elementFound; + } + + public Integer getElementAt(Integer position) { + try { + if (position >= size || position < 0) + throw new BoundsException(); + } catch (BoundsException exception) { + exception.Error(); + } + return arr[position]; + } + + public Integer getSize() { + return size; + } + +} \ No newline at end of file diff --git a/OrderedList/LinearListImplementation/BoundsException.java b/OrderedList/LinearListImplementation/BoundsException.java new file mode 100644 index 0000000..e49db5e --- /dev/null +++ b/OrderedList/LinearListImplementation/BoundsException.java @@ -0,0 +1,6 @@ +class BoundsException extends Exception { + void Error() { + printStackTrace(); + System.out.println("Out of bounds exception occured!"); + } +} \ No newline at end of file diff --git a/OrderedList/LinearListImplementation/Driver.java b/OrderedList/LinearListImplementation/Driver.java new file mode 100644 index 0000000..53637e7 --- /dev/null +++ b/OrderedList/LinearListImplementation/Driver.java @@ -0,0 +1,48 @@ +import java.util.Scanner; + +class Driver { + public static void main(String arg[]) { + Scanner in = new Scanner(System.in); + OrderedLinkedList dataStructure = new OrderedLinkedList(); + int choice, userInput; + Boolean Continue = true; + System.out.println("MENU DRIVEN ORDEREDLIST"); + while (Continue) { + System.out.print( + "\n1) Enter new Data Element\n2) Search for an Element\n3) Traverse the whole array\n4) Find element by position\n5) Check if array is empty\n6) Exit\n\n Your CHOICE: "); + choice = in.nextInt(); + switch (choice) { + case 1: + System.out.print("Enter element to add: "); + userInput = in.nextInt(); + dataStructure.add(userInput); + break; + case 2: + System.out.print("Enter element to Search: "); + userInput = in.nextInt(); + dataStructure.search(userInput); + break; + case 3: + dataStructure.traverse(); + break; + case 4: + System.out.print("Enter index to get Element: "); + userInput = in.nextInt(); + System.out.println("Element at index " + userInput + " is " + dataStructure.getElementAt(userInput)); + break; + case 5: + if (dataStructure.isEmpty()) + System.out.println("DataStructure is empty!"); + else + System.out.println("DataStructure is not empty!"); + break; + case 6: + Continue = false; + break; + default: + System.out.println("Invalid Value! Enter 6 to exit!!"); + } + } + in.close(); + } +} \ No newline at end of file diff --git a/OrderedList/LinearListImplementation/LinkedList.java b/OrderedList/LinearListImplementation/LinkedList.java new file mode 100644 index 0000000..d6596b3 --- /dev/null +++ b/OrderedList/LinearListImplementation/LinkedList.java @@ -0,0 +1,8 @@ +interface List{ + Integer getElementAt(Integer position); + void add(Integer element); + void traverse(); + Boolean isEmpty(); + void search(Integer element); + Integer getSize(); +} \ No newline at end of file diff --git a/OrderedList/LinearListImplementation/ListObject.java b/OrderedList/LinearListImplementation/ListObject.java new file mode 100644 index 0000000..3439ee0 --- /dev/null +++ b/OrderedList/LinearListImplementation/ListObject.java @@ -0,0 +1,14 @@ +class ListObject { + Integer data; + ListObject next; + + ListObject() { + data = null; + next = null; + } + + ListObject(Integer element) { + data = element; + next = null; + } +} \ No newline at end of file diff --git a/OrderedList/LinearListImplementation/OrderedList.java b/OrderedList/LinearListImplementation/OrderedList.java new file mode 100644 index 0000000..eabc727 --- /dev/null +++ b/OrderedList/LinearListImplementation/OrderedList.java @@ -0,0 +1,75 @@ +class OrderedLinkedList implements List { + ListObject Head, iterator; + + OrderedLinkedList() { + Head = null; + } + + public Integer getElementAt(Integer position) { + return null; + } + + public void add(Integer element) { + ListObject obj = new ListObject(element); + if (Head == null) { + Head = obj; + } else { + iterator = Head; + ListObject previous = new ListObject(); + previous.next = Head; + while (iterator != null) { + if (iterator.data > element) { + previous.next = obj; + obj.next = iterator; + return; + } + iterator = iterator.next; + previous = previous.next; + } + previous.next = obj; + } + traverse(); + } + + public void traverse() { + iterator = Head; + System.out.print("DataStructure cotains: "); + while (iterator != null) { + System.out.print(iterator.data + " "); + iterator = iterator.next; + } + System.out.println(); + } + + public Boolean isEmpty() { + return getSize() == 0; + } + + public void search(Integer element) { + iterator = Head; + boolean found = false; + Integer index = 0; + while (iterator != null) { + if (iterator.data == element) { + System.out.println("Element " + element + " found at position " + index); + found = true; + break; + } + index++; + iterator = iterator.next; + } + if (found == false) + System.out.println("Element " + element + " not found!"); + } + + public Integer getSize() { + Integer size = 0; + iterator = Head; + while (iterator != null) { + size++; + iterator = iterator.next; + } + return size; + } + +} \ No newline at end of file diff --git a/Queue/ArrayList Implementation/BoundsException.java b/Queue/ArrayList Implementation/BoundsException.java new file mode 100644 index 0000000..c60d84a --- /dev/null +++ b/Queue/ArrayList Implementation/BoundsException.java @@ -0,0 +1,8 @@ +class BoundsException extends Exception { + private static final long serialVersionUID = 1L; + + void Error() { + printStackTrace(); + System.out.println("Out of bounds Exception occured!"); + } +} \ No newline at end of file diff --git a/Queue/ArrayList Implementation/Driver.java b/Queue/ArrayList Implementation/Driver.java new file mode 100644 index 0000000..8ee1b86 --- /dev/null +++ b/Queue/ArrayList Implementation/Driver.java @@ -0,0 +1,45 @@ +import java.util.Scanner; + +class Driver { + public static void main(String arg[]) { + Scanner in = new Scanner(System.in); + QueueAL dataStructure = new QueueAL(); + int choice, userInput; + Boolean Continue = true; + System.out.println("MENU DRIVEN QUEUE"); + while (Continue) { + System.out.print( + "\n1) Enqueue\n2) Dequeue\n3) Traverse\n4) Get Size\n5) Check if empty\n6) Exit\n\n Your CHOICE: "); + choice = in.nextInt(); + switch (choice) { + case 1: + System.out.print("Enter element to add: "); + userInput = in.nextInt(); + dataStructure.enqueue(userInput); + break; + case 2: + System.out.println("Removed element: " + dataStructure.dequeue()); + dataStructure.traverse(); + break; + case 3: + dataStructure.traverse(); + break; + case 4: + System.out.println("Size of data structure: " + dataStructure.getSize()); + break; + case 5: + if (dataStructure.isEmpty()) + System.out.println("DataStructure is empty!"); + else + System.out.println("DataStructure is not empty!"); + break; + case 6: + Continue = false; + break; + default: + System.out.println("Invalid Value! Enter 6 to exit!!"); + } + } + in.close(); + } +} \ No newline at end of file diff --git a/Queue/ArrayList Implementation/List.java b/Queue/ArrayList Implementation/List.java new file mode 100644 index 0000000..05d65a0 --- /dev/null +++ b/Queue/ArrayList Implementation/List.java @@ -0,0 +1,7 @@ +interface List{ + void enqueue(Integer element); + Integer dequeue(); + void traverse(); + Integer getSize(); + boolean isEmpty(); +} \ No newline at end of file diff --git a/Queue/ArrayList Implementation/QueueAL.java b/Queue/ArrayList Implementation/QueueAL.java new file mode 100644 index 0000000..782c86f --- /dev/null +++ b/Queue/ArrayList Implementation/QueueAL.java @@ -0,0 +1,55 @@ +class QueueAL implements List { + Integer arr[], size, initialSize; + + QueueAL() { + size = 0; + initialSize = 5; + arr = new Integer[initialSize]; + } + + public void enqueue(Integer element) { + if (size == initialSize) { + Integer temp[] = new Integer[initialSize *= 2]; + for (Integer i = 0; i < size; i++) { + temp[i] = arr[i]; + } + arr = temp; + } + arr[size++] = element; + traverse(); + } + + public Integer dequeue() { + Integer popped; + try { + if (size == 0) { + throw new BoundsException(); + } + } catch (BoundsException error) { + error.Error(); + } + popped = arr[0]; + for (Integer i = 0; i < size - 1; i++) { + arr[i] = arr[i + 1]; + } + size--; + return popped; + } + + public void traverse() { + System.out.print("DataStructure content: Head<-"); + for (Integer i = 0; i < size; i++) { + System.out.print(arr[i] + "<-"); + } + System.out.println("Tail"); + } + + public Integer getSize() { + return size; + } + + public boolean isEmpty() { + return size == 0; + } + +} \ No newline at end of file diff --git a/Queue/LinkedList Implementation/BoundsException.java b/Queue/LinkedList Implementation/BoundsException.java new file mode 100644 index 0000000..c60d84a --- /dev/null +++ b/Queue/LinkedList Implementation/BoundsException.java @@ -0,0 +1,8 @@ +class BoundsException extends Exception { + private static final long serialVersionUID = 1L; + + void Error() { + printStackTrace(); + System.out.println("Out of bounds Exception occured!"); + } +} \ No newline at end of file diff --git a/Queue/LinkedList Implementation/Driver.java b/Queue/LinkedList Implementation/Driver.java new file mode 100644 index 0000000..0667a08 --- /dev/null +++ b/Queue/LinkedList Implementation/Driver.java @@ -0,0 +1,45 @@ +import java.util.Scanner; + +class Driver { + public static void main(String arg[]) { + Scanner in = new Scanner(System.in); + QueueLL dataStructure = new QueueLL(); + int choice, userInput; + Boolean Continue = true; + System.out.println("MENU DRIVEN QUEUE"); + while (Continue) { + System.out.print( + "\n1) Enqueue\n2) Dequeue\n3) Traverse\n4) Get Size\n5) Check if empty\n6) Exit\n\n Your CHOICE: "); + choice = in.nextInt(); + switch (choice) { + case 1: + System.out.print("Enter element to add: "); + userInput = in.nextInt(); + dataStructure.enqueue(userInput); + break; + case 2: + System.out.println("Removed element: " + dataStructure.dequeue()); + dataStructure.traverse(); + break; + case 3: + dataStructure.traverse(); + break; + case 4: + System.out.println("Size of data structure: " + dataStructure.getSize()); + break; + case 5: + if (dataStructure.isEmpty()) + System.out.println("DataStructure is empty!"); + else + System.out.println("DataStructure is not empty!"); + break; + case 6: + Continue = false; + break; + default: + System.out.println("Invalid Value! Enter 6 to exit!!"); + } + } + in.close(); + } +} \ No newline at end of file diff --git a/Queue/LinkedList Implementation/ListObject.java b/Queue/LinkedList Implementation/ListObject.java new file mode 100644 index 0000000..24df2be --- /dev/null +++ b/Queue/LinkedList Implementation/ListObject.java @@ -0,0 +1,14 @@ +class ListObject { + Integer data; + ListObject next; + + ListObject(Integer value) { + data = value; + next = null; + } + + ListObject() { + data = null; + next = null; + } +} \ No newline at end of file diff --git a/Queue/LinkedList Implementation/Queue.java b/Queue/LinkedList Implementation/Queue.java new file mode 100644 index 0000000..4115571 --- /dev/null +++ b/Queue/LinkedList Implementation/Queue.java @@ -0,0 +1,7 @@ +interface Queue{ + void enqueue(Integer element); + Integer dequeue(); + void traverse(); + Integer getSize(); + Boolean isEmpty(); +} \ No newline at end of file diff --git a/Queue/LinkedList Implementation/QueueLL.java b/Queue/LinkedList Implementation/QueueLL.java new file mode 100644 index 0000000..d49148d --- /dev/null +++ b/Queue/LinkedList Implementation/QueueLL.java @@ -0,0 +1,61 @@ +class QueueLL implements Queue { + ListObject Head, iterator; + + QueueLL() { + Head = null; + iterator = null; + } + + public void enqueue(Integer element) { + if (Head == null) { + Head = new ListObject(element); + } else { + ListObject obj = new ListObject(element); + iterator = Head; + while (iterator.next != null) { + iterator = iterator.next; + } + iterator.next = obj; + } + traverse(); + } + + public Integer dequeue() { + Integer popped; + try { + if (Head == null) { + throw new BoundsException(); + } + } catch (BoundsException error) { + error.Error(); + } + popped = Head.data; + Head = Head.next; + return popped; + } + + public void traverse() { + iterator = Head; + System.out.print("Data Structure contains: Head<-"); + while (iterator != null) { + System.out.print(iterator.data + "<-"); + iterator = iterator.next; + } + System.out.println("Tail"); + } + + public Integer getSize() { + iterator = Head; + Integer size = 0; + while (iterator != null) { + size++; + iterator = iterator.next; + } + return size; + } + + public Boolean isEmpty() { + return getSize() == 0; + } + +} \ No newline at end of file diff --git a/Stack/ArrayList Implementation/BoundsException.java b/Stack/ArrayList Implementation/BoundsException.java new file mode 100644 index 0000000..c60d84a --- /dev/null +++ b/Stack/ArrayList Implementation/BoundsException.java @@ -0,0 +1,8 @@ +class BoundsException extends Exception { + private static final long serialVersionUID = 1L; + + void Error() { + printStackTrace(); + System.out.println("Out of bounds Exception occured!"); + } +} \ No newline at end of file diff --git a/Stack/ArrayList Implementation/Driver.java b/Stack/ArrayList Implementation/Driver.java new file mode 100644 index 0000000..efca4e7 --- /dev/null +++ b/Stack/ArrayList Implementation/Driver.java @@ -0,0 +1,42 @@ +import java.util.Scanner; + +class Driver { + public static void main(String arg[]) { + Scanner in = new Scanner(System.in); + Stack dataStructure = new Stack(); + int choice, userInput; + Boolean Continue = true; + System.out.println("\nMENU DRIVEN STACK"); + while (Continue) { + System.out.print( + "\n\n1) Push to Stack\n2) Pop from Stack\n3) Traverse the Stack\n4) Get Size of Stack\n5) Check Stack is empty\n6) Exit\n\nYOUR CHOICE: "); + choice = in.nextInt(); + switch (choice) { + case 1: + System.out.print("Enter element to push: "); + userInput = in.nextInt(); + dataStructure.push(userInput); + break; + case 2: + System.out.println("Popped element " + dataStructure.pop()); + dataStructure.traverse(); + break; + case 3: + dataStructure.traverse(); + break; + case 4: + System.out.print("Size of Stack is: " + dataStructure.getSize()); + break; + case 5: + System.out.print("Is the Stack Empty : " + dataStructure.isEmpty()); + break; + case 6: + Continue = false; + break; + default: + System.out.print("Invalid Inpit !!"); + } + } + in.close(); + } +} \ No newline at end of file diff --git a/Stack/ArrayList Implementation/List.java b/Stack/ArrayList Implementation/List.java new file mode 100644 index 0000000..9665a6a --- /dev/null +++ b/Stack/ArrayList Implementation/List.java @@ -0,0 +1,7 @@ +interface List{ + Integer pop(); + void push(Integer element); + void traverse(); + Integer getSize(); + Boolean isEmpty(); +} \ No newline at end of file diff --git a/Stack/ArrayList Implementation/Stack.java b/Stack/ArrayList Implementation/Stack.java new file mode 100644 index 0000000..e5eb469 --- /dev/null +++ b/Stack/ArrayList Implementation/Stack.java @@ -0,0 +1,48 @@ +class Stack implements List { + Integer arr[], size, initialSize; + + Stack() { + size = 0; + initialSize = 5; + arr = new Integer[initialSize]; + + } + + public void push(Integer element) { + if (size == initialSize) { + Integer tempArr[] = new Integer[initialSize *= 2]; + for (Integer i = 0; i < size; i++) + tempArr[i] = arr[i]; + arr = tempArr; + } + arr[size++] = element; + traverse(); + } + + public Integer pop() { + try { + if (size == 0) + throw new BoundsException(); + } catch (BoundsException error) { + error.Error(); + } + return arr[(size--) - 1]; + } + + public void traverse() { + System.out.print("Data Structure contains: "); + for (Integer i = 0; i < size; i++) { + System.out.print(arr[i] + " "); + } + System.out.println(); + } + + public Integer getSize() { + return size; + } + + public Boolean isEmpty() { + return size == 0; + } + +} \ No newline at end of file diff --git a/Stack/LinearList Implementation/BoundsException.java b/Stack/LinearList Implementation/BoundsException.java new file mode 100644 index 0000000..c60d84a --- /dev/null +++ b/Stack/LinearList Implementation/BoundsException.java @@ -0,0 +1,8 @@ +class BoundsException extends Exception { + private static final long serialVersionUID = 1L; + + void Error() { + printStackTrace(); + System.out.println("Out of bounds Exception occured!"); + } +} \ No newline at end of file diff --git a/Stack/LinearList Implementation/Driver.java b/Stack/LinearList Implementation/Driver.java new file mode 100644 index 0000000..8fae72d --- /dev/null +++ b/Stack/LinearList Implementation/Driver.java @@ -0,0 +1,42 @@ +import java.util.Scanner; + +class Driver { + public static void main(String arg[]) { + Scanner in = new Scanner(System.in); + StackLL dataStructure = new StackLL(); + Integer choice, userInput; + Boolean Continue = true; + System.out.println("MENU DRIVEN LINKEDLIST STACK"); + while (Continue) { + System.out.print( + "\n\n1) Push to Stack\n2) Pop from Stack\n3) Traverse the Stack\n4) Get Size of Stack\n5) Check Stack is empty\n6) Exit\n\nYOUR CHOICE: "); + choice = in.nextInt(); + switch (choice) { + case 1: + System.out.print("Enter element to push: "); + userInput = in.nextInt(); + dataStructure.push(userInput); + break; + case 2: + System.out.println("Popped element " + dataStructure.pop()); + dataStructure.traverse(); + break; + case 3: + dataStructure.traverse(); + break; + case 4: + System.out.print("Size of Stack is: " + dataStructure.getSize()); + break; + case 5: + System.out.print("Is the Stack Empty : " + dataStructure.isEmpty()); + break; + case 6: + Continue = false; + break; + default: + System.out.print("Invalid Inpit !!"); + } + } + in.close(); + } +} \ No newline at end of file diff --git a/Stack/LinearList Implementation/LinkedList.java b/Stack/LinearList Implementation/LinkedList.java new file mode 100644 index 0000000..10cd290 --- /dev/null +++ b/Stack/LinearList Implementation/LinkedList.java @@ -0,0 +1,7 @@ +interface LinkedList{ + void push(Integer element); + Integer pop(); + void traverse(); + Integer getSize(); + Boolean isEmpty(); +} \ No newline at end of file diff --git a/Stack/LinearList Implementation/ListObject.java b/Stack/LinearList Implementation/ListObject.java new file mode 100644 index 0000000..24df2be --- /dev/null +++ b/Stack/LinearList Implementation/ListObject.java @@ -0,0 +1,14 @@ +class ListObject { + Integer data; + ListObject next; + + ListObject(Integer value) { + data = value; + next = null; + } + + ListObject() { + data = null; + next = null; + } +} \ No newline at end of file diff --git a/Stack/LinearList Implementation/StackLL.java b/Stack/LinearList Implementation/StackLL.java new file mode 100644 index 0000000..7879f7a --- /dev/null +++ b/Stack/LinearList Implementation/StackLL.java @@ -0,0 +1,56 @@ +class StackLL implements LinkedList { + ListObject Head, temp; + + StackLL() { + Head = null; + temp = null; + } + + public void push(Integer element) { + if (Head == null) { + Head = new ListObject(element); + } else { + temp = new ListObject(element); + temp.next = Head; + Head = temp; + } + traverse(); + } + + public Integer pop() { + try { + if (Head == null) + throw new BoundsException(); + } catch (BoundsException error) { + error.Error(); + } + temp = Head; + Head = Head.next; + return temp.data; + } + + public void traverse() { + temp = Head; + System.out.print("DataStructure contet: "); + while (temp != null) { + System.out.print(temp.data + "<-"); + temp = temp.next; + } + System.out.println("Head"); + } + + public Integer getSize() { + Integer index = 0; + temp = Head; + while (temp != null) { + temp = temp.next; + index++; + } + return index; + } + + public Boolean isEmpty() { + return getSize() == 0 ? true : false; + } + +} \ No newline at end of file diff --git a/UnorderedList/ArrayList/ArrayList.java b/UnorderedList/ArrayList/ArrayList.java new file mode 100644 index 0000000..5a4194b --- /dev/null +++ b/UnorderedList/ArrayList/ArrayList.java @@ -0,0 +1,54 @@ +public class ArrayList implements List { + + Integer size, initialSize, arr[]; + + ArrayList() { + initialSize = 5; + size = 0; + arr = new Integer[initialSize]; + } + + public void add(Integer element) { + if (size == initialSize) { + Integer tempArray[] = new Integer[initialSize *= 2]; + for (int i = 0; i < size; i++) + tempArray[i] = arr[i]; + arr = tempArray; + } + arr[size] = element; + size++; + traverse(); + } + + public Boolean search(Integer element) { + for (Integer i = 0; i < size; i++) { + if (arr[i] == element) { + System.out.println("Element " + element + " found at index " + i); + return true; + } + } + return false; + } + + public Integer getElementAt(Integer position) { + try { + if (position < 0 || position >= size) + throw new BoundsException(); + } catch (BoundsException e) { + e.Error(); + } + return arr[position]; + } + + public void traverse() { + System.out.print("DataStructure content: "); + for (Integer i = 0; i < size; i++) { + System.out.print(arr[i]+" "); + } + System.out.println(""); + } + + public Boolean isEmpty() { + return size > 0 ? false : true; + } +} \ No newline at end of file diff --git a/UnorderedList/ArrayList/BoundsException.java b/UnorderedList/ArrayList/BoundsException.java new file mode 100644 index 0000000..c60d84a --- /dev/null +++ b/UnorderedList/ArrayList/BoundsException.java @@ -0,0 +1,8 @@ +class BoundsException extends Exception { + private static final long serialVersionUID = 1L; + + void Error() { + printStackTrace(); + System.out.println("Out of bounds Exception occured!"); + } +} \ No newline at end of file diff --git a/UnorderedList/ArrayList/Driver.java b/UnorderedList/ArrayList/Driver.java new file mode 100644 index 0000000..bf2da91 --- /dev/null +++ b/UnorderedList/ArrayList/Driver.java @@ -0,0 +1,49 @@ +import java.util.Scanner; + +class Driver { + public static void main(String arg[]) { + Scanner in = new Scanner(System.in); + ArrayList dataStructure = new ArrayList(); + int choice, userInput; + Boolean Continue = true; + System.out.println("MENU DRIVEN ARRAYLIST"); + while (Continue) { + System.out.print( + "\n1) Enter new Data Element\n2) Search for an Element\n3) Traverse the whole array\n4) Find element by position\n5) Check if array is empty\n6) Exit\n\n Your CHOICE: "); + choice = in.nextInt(); + switch (choice) { + case 1: + System.out.print("Enter element to add: "); + userInput = in.nextInt(); + dataStructure.add(userInput); + break; + case 2: + System.out.print("Enter element to Search: "); + userInput = in.nextInt(); + if (!dataStructure.search(userInput)) + System.out.println("Element " + userInput + " not found!"); + break; + case 3: + dataStructure.traverse(); + break; + case 4: + System.out.print("Enter index to get Element: "); + userInput = in.nextInt(); + System.out.println("Element at index " + userInput + " is " + dataStructure.getElementAt(userInput)); + break; + case 5: + if (dataStructure.isEmpty()) + System.out.println("DataStructure is empty!"); + else + System.out.println("DataStructure is not empty!"); + break; + case 6: + Continue = false; + break; + default: + System.out.println("Invalid Value! Enter 6 to exit!!"); + } + } + in.close(); + } +} \ No newline at end of file diff --git a/UnorderedList/ArrayList/List.java b/UnorderedList/ArrayList/List.java new file mode 100644 index 0000000..0bda691 --- /dev/null +++ b/UnorderedList/ArrayList/List.java @@ -0,0 +1,7 @@ +interface List{ + void add(Integer element); + Boolean search(Integer element); + Integer getElementAt(Integer position); + void traverse(); + Boolean isEmpty(); +} \ No newline at end of file diff --git a/UnorderedList/LinearList/BoundsException.java b/UnorderedList/LinearList/BoundsException.java new file mode 100644 index 0000000..c60d84a --- /dev/null +++ b/UnorderedList/LinearList/BoundsException.java @@ -0,0 +1,8 @@ +class BoundsException extends Exception { + private static final long serialVersionUID = 1L; + + void Error() { + printStackTrace(); + System.out.println("Out of bounds Exception occured!"); + } +} \ No newline at end of file diff --git a/UnorderedList/LinearList/Driver.java b/UnorderedList/LinearList/Driver.java new file mode 100644 index 0000000..ebabc30 --- /dev/null +++ b/UnorderedList/LinearList/Driver.java @@ -0,0 +1,66 @@ +import java.util.Scanner; + +class Driver { + public static void main(String arg[]) { + Scanner in = new Scanner(System.in); + LinearList dataStructure = new LinearList(); + int choice, userInput, position; + Boolean Continue = true; + System.out.println("MENU DRIVEN LINEARLIST"); + while (Continue) { + System.out.print( + "\n1) Enter new Data Element\n2) Enter new Data Element at position\n3) Search for an Element\n4) Traverse the whole array\n5) Find element by position\n6) Remove elements from List\n7) Reverse the whole array\n8) Check if data structure is empty\n9) Get Size\n10) Exit\n\n Your CHOICE: "); + choice = in.nextInt(); + switch (choice) { + case 1: + System.out.print("Enter element to add: "); + userInput = in.nextInt(); + dataStructure.add(userInput); + break; + case 2: + System.out.print("Enter element to add: "); + userInput = in.nextInt(); + System.out.print("Enter position: "); + position = in.nextInt(); + dataStructure.add(userInput, position); + break; + case 3: + System.out.print("Enter element to Search: "); + userInput = in.nextInt(); + dataStructure.search(userInput); + break; + case 4: + dataStructure.traverse(); + break; + case 5: + System.out.print("Enter index to get Element: "); + userInput = in.nextInt(); + System.out.println("Element at index " + userInput + " is " + dataStructure.getElementAt(userInput)); + break; + case 6: + System.out.print("Enter element to delete: "); + userInput = in.nextInt(); + dataStructure.remove(userInput); + break; + case 7: + dataStructure.reverse(); + break; + case 8: + if (dataStructure.isEmpty()) + System.out.println("DataStructure is empty!"); + else + System.out.println("DataStructure is not empty!"); + break; + case 9: + System.out.println("Size of data structure is: " + dataStructure.size()); + break; + case 10: + Continue = false; + break; + default: + System.out.println("Invalid Value! Enter 6 to exit!!"); + } + } + in.close(); + } +} \ No newline at end of file diff --git a/UnorderedList/LinearList/LinearList.java b/UnorderedList/LinearList/LinearList.java new file mode 100644 index 0000000..66da097 --- /dev/null +++ b/UnorderedList/LinearList/LinearList.java @@ -0,0 +1,154 @@ +class LinearList implements List { + ListObject Head, iterator; + + LinearList() { + Head = null; + } + + public void add(Integer element) { + ListObject obj = new ListObject(element); + if (Head == null) { + Head = obj; + } else { + iterator = Head; + while (iterator.next != null) { + iterator = iterator.next; + } + iterator.next = obj; + } + traverse(); + } + + public void add(Integer element, Integer position) { + iterator = Head; + Integer index = 0; + ListObject obj = new ListObject(element); + ListObject temp = new ListObject(); + try { + if (position < 0 || position > size()) + throw new BoundsException(); + } catch (BoundsException error) { + error.Error(); + } + while (iterator != null) { + if (position == 0) { + obj.next = Head; + Head = obj; + break; + } else if (index++ == position - 1) { + temp = iterator.next; + iterator.next = obj; + obj.next = temp; + } + iterator = iterator.next; + } + + traverse(); + } + + public void traverse() { + iterator = Head; + System.out.print("Data Structure contains: "); + while (iterator != null) { + System.out.print(iterator.data + " "); + iterator = iterator.next; + } + System.out.println(); + } + + public void search(Integer element) { + Integer index = 0; + iterator = Head; + while (iterator != null) { + if (iterator.data == element) { + System.out.println("Element " + element + " found at index " + index); + return; + } + iterator = iterator.next; + index++; + } + System.out.println("Element " + element + " not found"); + } + + public void remove(Integer element) { + iterator = Head; + ListObject previous = new ListObject(); + previous = null; + while (iterator != null) { + if (iterator.data == element) { + if (iterator == Head) { + Head = iterator.next; + break; + } + previous.next = iterator.next; + break; + } + previous = iterator; + iterator = iterator.next; + } + traverse(); + } + + public void reverse() { + ListObject current, previous, next; + current = next = Head; + previous = null; + while (current != null) { + next = current.next; + current.next = previous; + previous = current; + current = next; + } + Head = previous; + } + + // public Integer getElementAt(Integer position) { + // iterator = Head; + // Integer index; + // try { + // if (position < 0 || position >= size()) + // throw new BoundsException(); + // } catch (BoundsException error) { + // error.Error(); + // } + // for (index = 0; index < position; index++) { + // iterator = iterator.next; + // System.out.println("looping through iterator " + index); + // } + // return iterator.data; + // } + + public Integer getElementAt(Integer position) { + Integer index = 0; + try { + if (position < 0 || position >= size()) + throw new BoundsException(); + } catch (BoundsException error) { + error.Error(); + } + iterator = Head; + while (iterator != null) { + if (index == position) { + return iterator.data; + } + iterator = iterator.next; + index++; + } + return iterator.data; + } + + public Integer size() { + Integer size = 0; + iterator = Head; + while (iterator != null) { + iterator = iterator.next; + size++; + } + return size; + } + + public Boolean isEmpty() { + return Head == null ? true : false; + } + +} \ No newline at end of file diff --git a/UnorderedList/LinearList/List.java b/UnorderedList/LinearList/List.java new file mode 100644 index 0000000..3501b52 --- /dev/null +++ b/UnorderedList/LinearList/List.java @@ -0,0 +1,19 @@ +interface List { + void add(Integer element); + + void add(Integer element, Integer position); + + void search(Integer element); + + void traverse(); + + void remove(Integer element); + + void reverse(); + + Integer getElementAt(Integer position); + + Integer size(); + + Boolean isEmpty(); +} \ No newline at end of file diff --git a/UnorderedList/LinearList/ListObject.java b/UnorderedList/LinearList/ListObject.java new file mode 100644 index 0000000..8fa4c31 --- /dev/null +++ b/UnorderedList/LinearList/ListObject.java @@ -0,0 +1,14 @@ +class ListObject { + Integer data; + ListObject next; + + ListObject(Integer i) { + data = i; + next = null; + } + + ListObject() { + data = null; + next = null; + } +} \ No newline at end of file