add linked list

Author: Aman Kumar

bst/bst.rb

@@ -7,24 +7,31 @@ def initialize(values = [])
     values.each { |value| insert(value) } if values.any?
   end
 
-  def insert(value)
-    insert_helper(value)
-  end
-
   def print
     puts inorder(@root).to_s
   end
 
-  def insert_helper(value, node = @root)
+  def insert(value, node = @root)
     if node.nil?
       node = TreeNode.new(value)
       @root = node if @root.nil?
       return node
     end
     if value < node.val
-      node.left.nil? ? node.left = TreeNode.new(value) : insert_helper(value, node.left)
+      node.left = insert(value, node.left)
     elsif value > node.val
-      node.right.nil? ? node.right = TreeNode.new(value) : insert_helper(value, node.right)
+      node.right = insert(value, node.right)
+    end
+    node
+  end
+
+  def search(val, node = @root)
+    return false if node.nil?
+
+    case val <=> node.val
+    when 1 then search(val, node.right)
+    when -1 then search(val, node.left)
+    when 0 then true
     end
   end
 
@@ -36,9 +43,62 @@ def inorder(node, output = [])
     inorder(node.right, output)
     output
   end
+
+  def min(node = @root)
+    return nil if node.nil?
+
+    current = node
+    while current
+      min = current.val
+      current = current.left
+    end
+    min
+  end
+
+  def max(node = @root)
+    return nil if node.nil?
+
+    current = node
+    while current
+      max = current.val
+      current = current.right
+    end
+    max
+  end
+
+  def delete(val, node = @root)
+    return if node.nil?
+
+    if val < node.val
+      node.left = delete(val, node.left)
+    elsif val > node.val
+      node.right = delete(val, node.right)
+    elsif node.left.nil? && node.right.nil?
+      # leaf node
+      return nil
+    elsif node.left.nil? # only left child
+      return node.right
+    elsif node.right.nil? # only right child
+      return node.left
+    else
+      # both left and right subtree
+      replacement = min(node.right)
+      node.val = replacement
+      node.right = delete(replacement, node.right)
+      return node
+
+    end
+    node
+  end
 end
 
-bst = BST.new([4, 33, 4, 5, 6, 42, 7])
+bst = BST.new([10, 2, 33, 4, 5, 3, 42])
 bst.print
 
-puts bst.root.to_s
+# puts bst.search(4)
+# puts bst.min
+
+# puts bst.max
+
+puts bst.delete(4)
+puts bst.print

linklist/delete

@@ -0,0 +1,32 @@
+# Given a linked list, return the node where the cycle begins. If there is no cycle, return null.
+
+require_relative './linklist'
+
+def detectCycle(head)
+  slow = head
+  fast = head
+  while slow && fast && fast.next
+
+    slow = slow.next
+    fast = fast.next.next
+
+    next unless slow == fast
+
+    slow = head
+
+    while slow != fast
+      slow = slow.next
+      fast = fast.next
+    end
+
+    return fast
+  end
+  nil
+end
+
+# ll = LinkList.new([1, 2, 3, 4, 5, 6], 2)
+# puts detect_cycle(ll.head)
+#
+#
+ll = LinkList.new([1, 2], 0)
+puts detectCycle(ll.head)

linklist/detect_cycle_floyds_mathemetical.rb

@@ -0,0 +1,47 @@
+# Given a linked list, return the node where the cycle begins. If there is no cycle, return null.
+# Input: head = [3,2,0,-4], pos = 1
+# Output: tail connects to node index 1
+# Explanation: There is a cycle in the linked list, where tail connects to the second node.
+
+require_relative './linklist'
+
+# using hashing
+def detect_cycle_hasing(head)
+  return false if head.nil?
+
+  current = head
+  visited = { current.object_id => 0 }
+  index = 1
+  while current.next
+    puts visited
+    return "tail connects to node index #{visited[current.next.object_id]}" if visited[current.next.object_id]
+
+    visited[current.next.object_id] = index
+    current = current.next
+    index += 1
+  end
+
+  'no cycle'
+end
+
+# LeetCode submission
+def detectCycle(head)
+  return nil if head.nil?
+
+  current = head
+  visited = { current.object_id => 0 }
+  index = 1
+  while current.next
+    return current.next if visited[current.next.object_id]
+
+    visited[current.next.object_id] = index
+    current = current.next
+    index += 1
+  end
+
+  nil
+end
+
+ll = LinkList.new([1, 2, 3, 4, 5, 6], 5)
+# ll.print
+puts detect_cycle_hasing(ll.head)

linklist/detect_cycle_hashing.rb

@@ -0,0 +1,39 @@
+# Given a linked list, return the node where the cycle begins. If there is no cycle, return null.
+
+require_relative './linklist'
+
+def detect_cycle(head)
+  return nil if head.nil?
+
+  slow = head
+  fast = head.next
+  while slow && fast && fast.next
+    slow = slow.next
+    fast = fast.next.next
+    if slow == fast
+      find_node(head, slow)
+      break
+    end
+  end
+end
+
+def find_node(head, loop_node)
+  ptr1 = head
+  while true
+    ptr2 = loop_node
+
+    ptr2 = ptr2.next while ptr2.next != loop_node && ptr2.next != ptr1
+    if ptr2.next == ptr1
+      # ptr2 is last node of loop
+      #  TO remove loop, we can just make ptr2.next = None
+      puts ptr2.val
+      return ptr2
+    else
+      ptr1 = ptr1.next
+    end
+  end
+end
+
+ll = LinkList.new([1, 2, 3, 4, 5, 6], 0)
+# ll.print
+puts detect_cycle(ll.head)

linklist/detect_cycle_one_by_one.rb

@@ -0,0 +1,34 @@
+require_relative './linklist'
+
+# Floyd's Tortoise and Hare Algorithm
+def has_cycle?(head)
+  return false if head.nil?
+
+  slow = head
+  fast = head
+  while !slow.nil? && !fast.nil? && !fast.next.nil?
+    slow = slow.next
+    fast = fast.next.next
+    return true if slow == fast
+  end
+  false
+end
+
+# using hashing
+def has_cycle1?(head)
+  return false if head.nil?
+
+  visited = {}
+
+  while head
+    return true if visited[head.object_id]
+
+    visited[head.object_id] = true
+    head = head.next
+  end
+
+  false
+end
+
+ll = LinkList.new([1, 2, 3, 4, 5, 6], 3)
+puts has_cycle1?(ll.head)

linklist/has_cycle.rb

@@ -0,0 +1,28 @@
+def getIntersectionNode(headA, headB)
+  return nil if headA.nil? || headB.nil?
+
+  a_pointer = headA
+  b_pointer = headB
+
+  # iterate till both pointers point to the same node
+  while a_pointer != b_pointer
+
+    # once a_pointer reaches end of the headA, point it to start of head B
+    # for A = totally 5 nodes + 2 nodes to reach intersection point.
+    a_pointer = if a_pointer.nil?
+                  headB
+                else
+                  a_pointer.next
+                end
+
+    # once b_pointer reaches end of the headB, point it to start of head A
+    # for B = totally 3 nodes + 4 nodes to reach intersection point.
+    b_pointer = if b_pointer.nil?
+                  headA
+                else
+                  b_pointer.next
+                end
+  end
+  # at this point both of the pointers will be pointing to the same node.
+  a_pointer
+end

linklist/intersection_point_2_pointers.rb

@@ -0,0 +1,16 @@
+def getIntersectionNode(headA, headB)
+  return nil if headA.nil? || headB.nil?
+
+  visited = {}
+  while headA
+    visited[headA.object_id] = true
+    headA = headA.next
+  end
+
+  while headB
+    return headB if visited.has_key? headB.object_id
+
+    headB = headB.next
+  end
+  nil
+end

linklist/intersection_point_hashmap.rb

@@ -0,0 +1,37 @@
+def getIntersectionNode(headA, headB)
+  return nil if headA.nil? || headB.nil?
+
+  l1 = length(headA)
+  l2 = length(headB)
+  diff = (l1 - l2).abs
+
+  if l1 > l2
+    largerH = headA
+    smallerH = headB
+  else
+    largerH = headB
+    smallerH = headA
+  end
+
+  while largerH.next && diff > 0
+    largerH = largerH.next
+    diff -= 1
+  end
+
+  while largerH != smallerH
+    largerH = largerH.next
+    smallerH = smallerH.next
+  end
+  largerH
+end
+
+def length(node)
+  return 0 if node.nil?
+
+  count = 0
+  while node
+    count += 1
+    node = node.next
+  end
+  count
+end