From 5b203f0f263bd819f5ed79408410cad1ea45bb40 Mon Sep 17 00:00:00 2001
From: vwhwang <vwhwang38@gmail.com>
Date: Thu, 20 Aug 2020 15:34:15 -0700
Subject: [PATCH 1/4] up to find min

---
 lib/linked_list.rb | 64 +++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 55 insertions(+), 9 deletions(-)

diff --git a/lib/linked_list.rb b/lib/linked_list.rb
index 0de1ee00..68d4ef16 100644
--- a/lib/linked_list.rb
+++ b/lib/linked_list.rb
@@ -3,10 +3,12 @@
 class Node
   attr_reader :data # allow external entities to read value but not write
   attr_accessor :next # allow external entities to read or write next node
+  attr_accessor :previous 
 
-  def initialize(value, next_node = nil)
+  def initialize(value, next_node = nil, previous = nil )
     @data = value
     @next = next_node
+    @previous = previous
   end
 end
 
@@ -14,28 +16,58 @@ def initialize(value, next_node = nil)
 class LinkedList
     def initialize
       @head = nil # keep the head private. Not accessible outside this class
+      @tail = nil 
     end
 
     # method to add a new node with the specific data value in the linked list
     # insert the new node at the beginning of the linked list
-    # Time Complexity: ?
-    # Space Complexity: ?
+    # Time Complexity: O(1)
+    # Space Complexity: O(1)
     def add_first(value)
-      raise NotImplementedError
+      if @head.nil? 
+        @head = @tail = Node.new(value)
+      else
+        new_node = Node.new(value,@head)
+        @head.previous = new_node 
+        @head = new_node  
+      end 
     end
 
     # method to find if the linked list contains a node with specified value
     # returns true if found, false otherwise
-    # Time Complexity: ?
-    # Space Complexity: ?
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)
     def search(value)
-      raise NotImplementedError
+      return false if @head.nil? 
+      pointer = @head 
+ 
+      until pointer.next.nil?
+       
+        if pointer.data == value || pointer.next.data == value 
+          return true 
+        else  
+          pointer = pointer.next 
+        end 
+
+      end 
+
+      return false 
     end
 
     # method to return the max value in the linked list
     # returns the data value and not the node
     def find_max
-      raise NotImplementedError
+      return nil if @head.nil? 
+      max = @head.data
+      pointer = @head
+      while !pointer.next.nil? 
+        if pointer.data > max 
+          max = pointer.data 
+        end 
+        pointer = pointer.next 
+      end 
+      return @tail.data if @tail.data > max 
+      return max 
     end
 
     # method to return the min value in the linked list
@@ -43,7 +75,21 @@ def find_max
     # Time Complexity: ?
     # Space Complexity: ?
     def find_min
-      raise NotImplementedError
+      return nil if @head.nil? 
+
+      min = @head.data
+   
+      pointer = @head
+      while !pointer.next.nil? 
+        if pointer.data < min 
+          min = pointer.data 
+        elsif pointer.tail < min 
+          min = pointer.tail 
+        end 
+        pointer = pointer.next 
+      end 
+     
+      return min 
     end
 
 

From 5a1172e049df1eadb3fb5d1d5d922b8d7d651e67 Mon Sep 17 00:00:00 2001
From: vwhwang <vwhwang38@gmail.com>
Date: Thu, 20 Aug 2020 15:56:34 -0700
Subject: [PATCH 2/4] passed get_at_index

---
 lib/linked_list.rb | 34 ++++++++++++++++++++++++++--------
 1 file changed, 26 insertions(+), 8 deletions(-)

diff --git a/lib/linked_list.rb b/lib/linked_list.rb
index 68d4ef16..476f18da 100644
--- a/lib/linked_list.rb
+++ b/lib/linked_list.rb
@@ -72,8 +72,8 @@ def find_max
 
     # method to return the min value in the linked list
     # returns the data value and not the node
-    # Time Complexity: ?
-    # Space Complexity: ?
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)
     def find_min
       return nil if @head.nil? 
 
@@ -94,19 +94,37 @@ def find_min
 
 
     # method that returns the length of the singly linked list
-    # Time Complexity: ?
-    # Space Complexity: ?
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)
     def length
-      raise NotImplementedError
+      count = 1 
+      return 0 if @head.nil? 
+      pointer = @head
+      until pointer.next.nil? 
+        count += 1 
+        pointer = pointer.next
+      end 
+      return count 
     end
 
     # method that returns the value at a given index in the linked list
     # index count starts at 0
     # returns nil if there are fewer nodes in the linked list than the index value
-    # Time Complexity: ?
-    # Space Complexity: ?
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)
     def get_at_index(index)
-      raise NotImplementedError
+      node_index = 0 
+      pointer = @head 
+      until pointer.nil? 
+       if node_index == index 
+        return pointer.data 
+       else 
+        node_index += 1 
+       end 
+       pointer = pointer.next 
+      end 
+  
+      return nil 
     end
 
     # method to print all the values in the linked list

From 20230bc2e9da3822c5722d20909cab59c39ef808 Mon Sep 17 00:00:00 2001
From: vwhwang <vwhwang38@gmail.com>
Date: Mon, 24 Aug 2020 09:43:28 -0700
Subject: [PATCH 3/4] in progress of fixing delete

---
 lib/linked_list.rb | 91 +++++++++++++++++++++++++++++++++++++---------
 1 file changed, 74 insertions(+), 17 deletions(-)

diff --git a/lib/linked_list.rb b/lib/linked_list.rb
index 476f18da..c5141e89 100644
--- a/lib/linked_list.rb
+++ b/lib/linked_list.rb
@@ -60,13 +60,13 @@ def find_max
       return nil if @head.nil? 
       max = @head.data
       pointer = @head
-      while !pointer.next.nil? 
+
+      while !pointer.nil?
         if pointer.data > max 
           max = pointer.data 
         end 
         pointer = pointer.next 
       end 
-      return @tail.data if @tail.data > max 
       return max 
     end
 
@@ -80,15 +80,13 @@ def find_min
       min = @head.data
    
       pointer = @head
-      while !pointer.next.nil? 
-        if pointer.data < min 
+      while !pointer.nil?
+        if pointer.data < min
           min = pointer.data 
-        elsif pointer.tail < min 
-          min = pointer.tail 
         end 
         pointer = pointer.next 
       end 
-     
+    
       return min 
     end
 
@@ -128,17 +126,47 @@ def get_at_index(index)
     end
 
     # method to print all the values in the linked list
-    # Time Complexity: ?
-    # Space Complexity: ?
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)
     def visit
-      raise NotImplementedError
+      pointer = @head 
+      while !pointer.nil? 
+        puts pointer.data 
+        pointer = pointer.next 
+      end 
     end
 
     # method to delete the first node found with specified value
-    # Time Complexity: ?
-    # Space Complexity: ?
+    # Time Complexity: O(n)
+    # Space Complexity: O(n)
+ 
     def delete(value)
-      raise NotImplementedError
+      
+      pointer = @head 
+
+
+      while !pointer.nil? 
+       if pointer.data == value 
+        if pointer == @head && pointer == @tail 
+          @head = @tail = nil
+          return 
+        elsif pointer == @head 
+          @head = pointer.next
+          @head.previous = nil
+          return
+        elsif pointer == @tail
+          @tail = pointer.previous
+          @tail.next = nil
+          return
+        else  
+          pointer.next.previous = pointer.previous
+          pointer.previous.next = pointer.next
+          return
+        end 
+       end 
+       pointer = pointer.next 
+      end 
+  
     end
 
     # method to reverse the singly linked list
@@ -146,7 +174,17 @@ def delete(value)
     # Time Complexity: ?
     # Space Complexity: ?
     def reverse
-      raise NotImplementedError
+      pointer = @head 
+
+      while !pointer.nil?
+        temp = pointer.previous
+        pointer.previous = pointer.next 
+        pointer.next = temp 
+        pointer = pointer.previous
+      end 
+        temp = @head
+        @head = @tail
+        @tail = temp
     end
 
 
@@ -182,14 +220,26 @@ def has_cycle
     # Time Complexity: ?
     # Space Complexity: ?
     def get_first
-      raise NotImplementedError
+      return nil if @head.nil? 
+      return @head.data 
     end
 
     # method that inserts a given value as a new last node in the linked list
     # Time Complexity: ?
     # Space Complexity: ?
     def add_last(value)
-      raise NotImplementedError
+      
+      if @head.nil?
+        @head = Node.new(value,@head)
+        return 
+      end 
+
+      current = @head 
+      until current.next.nil? 
+        current = current.next 
+      end 
+
+      current.next = Node.new(value)
     end
 
     # method that returns the value of the last node in the linked list
@@ -197,7 +247,14 @@ def add_last(value)
     # Time Complexity: ?
     # Space Complexity: ?
     def get_last
-      raise NotImplementedError
+      
+      current = @head 
+
+      until current.next.nil?
+        current = current.next
+      end 
+
+      return current.data
     end
 
     # method to insert a new node with specific data value, assuming the linked

From 177a3e1c77b4c16276b3a649a493a417f046966e Mon Sep 17 00:00:00 2001
From: vwhwang <vwhwang38@gmail.com>
Date: Mon, 24 Aug 2020 12:48:53 -0700
Subject: [PATCH 4/4] completed and passed test

---
 lib/linked_list.rb | 62 ++++++++++++++++++++++++++++++----------------
 1 file changed, 41 insertions(+), 21 deletions(-)

diff --git a/lib/linked_list.rb b/lib/linked_list.rb
index c5141e89..bf1cdf05 100644
--- a/lib/linked_list.rb
+++ b/lib/linked_list.rb
@@ -141,32 +141,33 @@ def visit
     # Space Complexity: O(n)
  
     def delete(value)
-      
+      return nil if @head.nil? 
       pointer = @head 
 
 
       while !pointer.nil? 
        if pointer.data == value 
-        if pointer == @head && pointer == @tail 
-          @head = @tail = nil
-          return 
-        elsif pointer == @head 
-          @head = pointer.next
-          @head.previous = nil
-          return
-        elsif pointer == @tail
+        if pointer == @head 
+          @head = pointer.next 
+        end 
+
+        if pointer == @tail
           @tail = pointer.previous
-          @tail.next = nil
-          return
-        else  
+        end 
+
+        if !pointer.next.nil?
           pointer.next.previous = pointer.previous
-          pointer.previous.next = pointer.next
-          return
         end 
+        
+        if !pointer.previous.nil?
+          pointer.previous.next = pointer.next 
+        end 
+        return
        end 
-       pointer = pointer.next 
+
+       pointer = pointer.next
       end 
-  
+      
     end
 
     # method to reverse the singly linked list
@@ -198,10 +199,26 @@ def find_middle_value
 
     # find the nth node from the end and return its value
     # assume indexing starts at 0 while counting to n
-    # Time Complexity: ?
-    # Space Complexity: ?
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)
     def find_nth_from_end(n)
-      raise NotImplementedError
+      node_index = 0
+      pointer = @tail 
+
+      until pointer == @head 
+       if node_index == n 
+        return pointer.data 
+       else 
+        node_index += 1 
+       end 
+       pointer = pointer.previous 
+      end 
+
+      if pointer == @head && (node_index  == n )
+        return @head.data
+      end 
+  
+      return nil 
     end
 
     # checks if the linked list has a cycle. A cycle exists if any node in the
@@ -229,8 +246,9 @@ def get_first
     # Space Complexity: ?
     def add_last(value)
       
+      temp = Node.new(value)
       if @head.nil?
-        @head = Node.new(value,@head)
+        @head = @tail = temp
         return 
       end 
 
@@ -239,7 +257,9 @@ def add_last(value)
         current = current.next 
       end 
 
-      current.next = Node.new(value)
+      current.next = temp
+      temp.previous = current
+      @tail = temp
     end
 
     # method that returns the value of the last node in the linked list