Ch. 16 practice problems

Author: neha-peddinti

src/com/codefortomorrow/advanced/chapter16/practice/Access.java

@@ -0,0 +1,12 @@
+package com.codefortomorrow.advanced.chapter16.practice;
+
+/*
+Using the methods outlined in the “Benefits of LinkedLists” section,
+fill both a LinkedList and an ArrayList with 10,000 elements.
+Then, find the time it takes to access the last element of each list.
+
+Determine which type of list can access elements more efficiently.
+
+Hint: You can use the get(int position) method
+to access the element at a given position of a list.
+*/

src/com/codefortomorrow/advanced/chapter16/practice/Names.java

@@ -0,0 +1,18 @@
+package com.codefortomorrow.advanced.chapter16.practice;
+
+/*
+Create a LinkedList of Strings, and ask the user to
+input 10 names one by one into the list.
+
+Output this list.
+
+Remove each name that has 5 or fewer letters, and output the new list.
+
+Add the word “Apple” to the beginning of the list.
+
+Add the word “Peanut” to the second-to-last position of the list.
+
+(Hint: Make sure to take advantage of LinkedList methods!)
+
+Output the new list.
+*/

src/com/codefortomorrow/advanced/chapter16/practice/SinglyLinkedListInsert.java

@@ -0,0 +1,31 @@
+package com.codefortomorrow.advanced.chapter16.practice;
+
+/*
+Adding an insert method to a SinglyLinkedList
+(details in SinglyLinkedList DIY section). 
+
+Hint: It might be necessary to have a separate case for
+inserting at position 0, because that’s when you want to
+insert BEFORE the head. For all other positions (1, 2, etc.),
+you can simply traverse down the list, keeping track of the
+current node, and when you reach the position you want,
+add the node AFTER the current node.
+
+Alternatively, you can always add BEFORE the current node
+for all position cases (insert before the head to place the
+new node at pos 0, insert before node 1 to place the new
+node at pos 1, etc.), but then your exception case would
+be when the user wants to insert a node at the very end of the list.
+In this case, you’d have to write separate code to insert AFTER
+the last node.
+
+Make sure you have a toString() method defined!
+
+The following code should output “{2, 3, 4, 7}”:
+SinglyLinkedList lst = new SinglyLinkedList();
+lst.add(3);
+lst.add(7);
+lst.insert(4, 1);
+lst.insert(2, 0);
+System.out.println(lst);
+*/

src/com/codefortomorrow/advanced/chapter16/practice/Sort.java

@@ -0,0 +1,8 @@
+package com.codefortomorrow.advanced.chapter16.practice;
+
+/*
+Write a method which takes in a LinkedList of Strings
+and rearranges the elements (without creating a new list)
+so it is sorted in ascending order of String length.
+Don’t use any pre-existing sort methods… write your own. :)
+*/

src/com/codefortomorrow/advanced/chapter16/solutions/Access.java

@@ -0,0 +1,42 @@
+package com.codefortomorrow.advanced.chapter16.solutions;
+import java.util.*;
+
+/*
+Using the methods outlined in the “Benefits of LinkedLists” section,
+fill both a LinkedList and an ArrayList with 10,000 elements.
+Then, find the time it takes to access the last element of each list.
+
+Determine which type of list can access elements more efficiently.
+
+Hint: You can use the get(int position) method
+to access the element at a given position of a list.
+*/
+
+public class Access {
+
+    public static void main(String[] args) {
+        long a, b;
+
+        // Define lists with 10,000 elements.
+        LinkedList<Integer> list1 = new LinkedList<Integer>();
+        for(int i = 0; i < 10000; i++)
+            list1.add(1);
+
+        ArrayList<Integer> list2 = new ArrayList<Integer>();
+        for(int i = 0; i < 10000; i++)
+            list2.add(1);
+
+        // Get time for each operation and output the difference.
+        a = System.nanoTime();
+        int c = list1.get(9999);
+        b = System.nanoTime();
+        System.out.println("\nLinked: " + (b-a) + " ns");
+
+        a = System.nanoTime();
+        int d = list2.get(9999);
+        b = System.nanoTime();
+        System.out.println("ArrayList: " + (b-a) + " ns");
+
+        // Note that the ArrayList takes less time.
+    }
+}

src/com/codefortomorrow/advanced/chapter16/solutions/Names.java

@@ -0,0 +1,40 @@
+package com.codefortomorrow.advanced.chapter16.solutions;
+import java.util.*;
+
+/*
+Create a LinkedList of Strings, and ask the user to
+input 10 names one by one into the list.
+
+Output this list.
+
+Remove each name that has 5 or fewer letters, and output the new list.
+
+Add the word “Apple” to the beginning of the list.
+
+Add the word “Peanut” to the second-to-last position of the list.
+
+(Hint: Make sure to take advantage of LinkedList methods!)
+
+Output the new list.
+*/
+
+public class Names {
+    public static void main(String[] args) {
+        LinkedList<String> list = new LinkedList<String>();
+        Scanner sc = new Scanner(System.in);
+        for(int i = 0; i < 10; i++) {
+          System.out.print("Enter name " + (i+1) + ": ");
+          list.add(sc.nextLine());
+        }
+        System.out.println(list);
+
+        for(int i = 0; i < list.size(); i++)
+          if(list.get(i).length() <= 5)
+                list.remove(i--);
+        System.out.println(list);
+
+        list.add(0, "Apple");
+        list.add(list.size() - 1, "Peanut");
+        System.out.println(list);
+    }
+}

src/com/codefortomorrow/advanced/chapter16/solutions/SinglyLinkedListInsert.java

@@ -0,0 +1,112 @@
+package com.codefortomorrow.advanced.chapter16.solutions;
+import java.util.*;
+
+/*
+Adding an insert method to a SinglyLinkedList
+(details in SinglyLinkedList DIY section). 
+
+Hint: It might be necessary to have a separate case for
+inserting at position 0, because that’s when you want to
+insert BEFORE the head. For all other positions (1, 2, etc.),
+you can simply traverse down the list, keeping track of the
+current node, and when you reach the position you want,
+add the node AFTER the current node.
+
+Alternatively, you can always add BEFORE the current node
+for all position cases (insert before the head to place the
+new node at pos 0, insert before node 1 to place the new
+node at pos 1, etc.), but then your exception case would
+be when the user wants to insert a node at the very end of the list.
+In this case, you’d have to write separate code to insert AFTER
+the last node.
+
+Make sure you have a toString() method defined!
+
+The following code should output “{2, 3, 4, 7}”:
+SinglyLinkedList lst = new SinglyLinkedList();
+lst.add(3);
+lst.add(7);
+lst.insert(4, 1);
+lst.insert(2, 0);
+System.out.println(lst);
+*/
+
+// NOTE: You need to make a separate class with a main()
+// method to use this List object. This is simply the object
+// definition.
+
+public class SinglyLinkedListInsert {
+  Node head;
+
+  // add() method from SinglyLinkedList DIY section, adds to end of list
+  public void add(int data) {
+    // Create a new node with given data 
+    Node new_node = new Node(data); 
+
+    // If the Linked List is empty, 
+    // then make the new node as head 
+    if (head == null) { 
+        head = new_node; 
+    } 
+    else { 
+        // Else traverse till the last node 
+        // and insert the new_node there 
+        Node last = head; 
+        while (last.next != null) { 
+            last = last.next; 
+        } 
+
+        // Insert the new_node at last node 
+        last.next = new_node; 
+    } 
+  }
+
+  public void insert(int data, int pos) {
+    // Verify valid pos number
+    if (pos < 0) 
+      System.out.print("Invalid position"); 
+
+    // Create new node and keep track of current node
+    Node new_node = new Node(data); 
+    Node current = head;
+
+    // If pos is 0, set new node as head
+    if (pos == 0) { 
+      new_node.next = head; 
+      head = new_node; 
+    } else { 
+      while (pos-- >= 0) { 
+        if (pos == 0) { 
+          // Add new node after current position
+          new_node.next = current.next;
+          current.next = new_node;
+          break; 
+        }
+        // Check if pos is out of bounds (reaches end)
+        if(current.next == null) {
+          System.out.println("Out of bounds");
+          break;
+        }
+        current = current.next; 
+      } 
+    } 
+  }
+
+  @Override
+  public String toString() {
+    // For empty lists
+    if(head == null)
+      return "{}";
+
+    String str = "{";
+    
+    // Traverse the list until the last node
+    Node current = head;
+    while(current.next != null) {
+      str += "" + current.data + ", ";
+      current = current.next;
+    }
+    str += current.data + "}";
+    return str;
+  }
+}

src/com/codefortomorrow/advanced/chapter16/solutions/Sort.java

@@ -0,0 +1,41 @@
+package com.codefortomorrow.advanced.chapter16.solutions;
+import java.util.*;
+
+/*
+Write a method which takes in a LinkedList of Strings
+and rearranges the elements (without creating a new list)
+so it is sorted in ascending order of String length.
+Don’t use any pre-existing sort methods… write your own. :)
+*/
+
+public class Sort {
+    public static void main(String[] args) {
+        LinkedList<String> list = new LinkedList<String>();
+        list.addAll(Arrays.asList(
+            "Jeannette", "Sophia", "Computer", "Boots",
+            "Lava", "Lasagna", "Dirty", "Cleanie"
+        ));
+        sort(list);
+        System.out.println(list);
+    }
+
+    public static void sort(LinkedList<String> list) {
+        if(list.size() < 2) return;
+        for(int i = 1; i < list.size(); i++) {
+            String current = list.get(i);
+            // Check if current word is smaller than previous word
+            if(current.length() < list.get(i-1).length()) {
+                // Add current word before the node with
+                // same or greater word size
+                for(int j = 0; j < i; j++) {
+                    if(list.get(j).length() >= current.length()) {
+                        list.add(j, current);
+                        // Remove duplicate current
+                        list.remove(i+1);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}