Merge pull request #3 from TheAlgorithms/minor-example-updates

update(list): Start with basic lists

Author: raksonibs

lib/data_structures/doubly_linked_list.ex

@@ -0,0 +1,65 @@
+defmodule Algorithims.DataStructures.DoublyLinkedList do
+  @moduledoc """
+  Because of elixir's immutability, there is no true way of having fully cyclical, referential structures. You would have to make a copy of the list with each change, and account for the new reference.
+  We will not write overly complex code to do that, and allow the user to understand the nuance here.
+
+  Access for DoublyLinkedList is O(n)
+  Search for DoublyLinkedList is O(n)
+  Deletion/Insertion at element is O(1)
+  """
+  defmodule Node, do: defstruct([:value, :prev, :next])
+  defmodule LinkedList, do: defstruct([:size, :head, :tail])
+
+  def get_node(%LinkedList{size: 0}, _value), do: nil
+
+  def get_node(%LinkedList{size: _size, head: head, tail: _tail}, value) do
+    check_node(head, value)
+  end
+
+  defp check_node(%Node{value: value, next: nil} = node, _value), do: nil
+
+  defp check_node(%Node{value: value, next: next} = node, value) do
+    if node.value == value do
+      node
+    else
+      check_node(node.next, value)
+    end
+  end
+
+  def set_node(list, value) do
+  end
+
+  def add_to_head(%LinkedList{head: nil, tail: nil, size: 0}, value) do
+    new_node = %Node{value: value, prev: nil, next: nil}
+    %LinkedList{head: new_node, tail: new_node, size: 1}
+  end
+
+  def add_to_head(%LinkedList{head: old_head, tail: tail, size: size}, value) do
+    new_head = %Node{prev: nil, next: old_head}
+    old_head = %Node{prev: new_head, next: old_head.next}
+    %LinkedList{size: size + 1, tail: tail, head: new_head}
+  end
+
+  def add_to_tail(%LinkedList{head: head, tail: old_tail, size: size}, value) do
+    new_tail = %Node{prev: old_tail, next: nil}
+    # old_tail.next = new_tail
+    %LinkedList{size: size + 1, tail: old_tail, head: head}
+  end
+
+  defp remove(%LinkedList{size: 0}, value), do: nil
+
+  defp remove(%LinkedList{size: size, head: head, tail: tail} = list, value) do
+    node_to_remove =
+      case get_node(list, value) do
+        nil -> raise "No node"
+        node -> node
+      end
+
+    # in elixir need to actually update references, this won't work in functional programming.
+    # previous = node_to_remove.prev
+    # next = node_to_remove.next
+    # previous.next = next
+    # next.previous = previous
+    %LinkedList{size: size - 1, head: head, tail: tail}
+  end
+end

lib/data_structures/singly_linked_list.ex

@@ -1,15 +1,71 @@
 defmodule Algorithims.DataStructures.SinglyLinkedList do
-  defmodule SingleLink, do: defstruct([:value, :reference])
+  @moduledoc """
+  Access for SinglyLinkedList is O(n)
+  Search for SinglyLinkedList is O(n)
+  Deletion/Insertion at element is O(1)
+  """
+  defmodule Node, do: defstruct([:value, :reference])
+  defmodule LinkedList, do: defstruct([:nodes])
 
-  def add_node([], value) do
-    [form_link(value, nil)]
+  @doc """
+  Adding to the head of a SinglyLinkedList is O(1), as you know where the head is
+  """
+  def add_node_head(%LinkedList{nodes: []}, value) do
+    first_link = form_link(value, nil)
+    %LinkedList{nodes: [first_link]}
   end
 
-  def add_node([head | _tail] = list, value) do
-    [form_link(value, head) | list]
+  def add_node_head(%LinkedList{nodes: [head | _tail] = list}, value) do
+    new_head = form_link(value, head)
+    %LinkedList{nodes: [new_head | list]}
+  end
+
+  @doc """
+  Adding to the tail/middle of a SinglyLinkedList is O(1)
+  """
+  def add_node_tail(%LinkedList{nodes: []} = list, value) do
+    add_node_head(list, value)
+  end
+
+  def add_node_tail(%LinkedList{nodes: [head | []]}, value) do
+    old_tail = head
+    new_tail = form_tail_link(value)
+    old_tail = %Node{value: old_tail.value, reference: new_tail}
+    new_nodes = [old_tail] ++ [new_tail]
+
+    %LinkedList{nodes: new_nodes}
+  end
+
+  def add_node_tail(%LinkedList{nodes: nodes} = list, value) do
+    old_tail = tail(list)
+    new_tail = form_tail_link(value)
+    old_tail = %Node{value: old_tail.value, reference: new_tail}
+    new_nodes = nodes |> List.delete_at(-1)
+    new_nodes = new_nodes ++ [old_tail] ++ [new_tail]
+
+    %LinkedList{nodes: new_nodes}
+  end
+
+  def list_length(%LinkedList{nodes: []}), do: 0
+  def list_length(%LinkedList{nodes: nodes}), do: nodes |> length()
+
+  def head(%LinkedList{nodes: nodes}), do: nodes |> List.first()
+
+  def tail(%LinkedList{nodes: [current_tail | []]}) do
+    current_tail
+  end
+
+  def tail(%LinkedList{nodes: []}), do: nil
+
+  def tail(%LinkedList{nodes: [_current_head | current_tails]}) do
+    tail(%LinkedList{nodes: current_tails})
   end
 
   defp form_link(value, reference) do
-    %__MODULE__.SingleLink{value: value, reference: reference}
+    %__MODULE__.Node{value: value, reference: reference}
+  end
+
+  defp form_tail_link(value) do
+    %__MODULE__.Node{value: value, reference: nil}
   end
 end

test/data_structures/doubly_linked_list_test.exs

@@ -0,0 +1,43 @@
+defmodule Algorithims.DataStructures.DoublyLinkedListTest do
+  alias Algorithims.DataStructures.DoublyLinkedList
+  alias DoublyLinkedList.LinkedList
+  alias DoublyLinkedList.Node
+
+  use ExUnit.Case
+  doctest Algorithims
+
+  describe "get_node/1" do
+    test "it works when the list is empty" do
+    end
+
+    test "it works when the list is not empty" do
+    end
+  end
+
+  describe "add_to_head/1" do
+    test "it works when the list is empty" do
+      res = DoublyLinkedList.add_to_head(%LinkedList{head: nil, tail: nil, size: 0}, 1)
+      assert res.size == 1
+      assert res.head == %Node{value: 1, prev: nil, next: nil}
+      assert res.tail == %Node{value: 1, prev: nil, next: nil}
+    end
+
+    test "it works when the list is not empty" do
+      res =
+        DoublyLinkedList.add_to_head(%LinkedList{head: nil, tail: nil, size: 0}, 10)
+        |> DoublyLinkedList.add_to_head(3)
+        |> DoublyLinkedList.add_to_head(5)
+        |> DoublyLinkedList.add_to_head(-1)
+
+      assert head = res.head
+      assert head.prev == nil
+      assert head.value == 10
+      assert head.next.value == 3
+
+      assert tail = res.tail
+      assert tail.prev.value == 5
+      assert tail.value == -1
+      assert tail.next == nil
+    end
+  end
+end

test/data_structures/singly_linked_list_test.exs

@@ -1,45 +1,72 @@
 defmodule Algorithims.DataStructures.SinglyLinkedListTest do
   alias Algorithims.DataStructures.SinglyLinkedList
+  alias SinglyLinkedList.LinkedList
+  alias SinglyLinkedList.Node
 
   use ExUnit.Case
   doctest Algorithims
 
-  describe "add_node/2" do
+  describe "add_node_head/2" do
     test "it works when the list is empty" do
-      assert SinglyLinkedList.add_node([], 3) == [
-               %SinglyLinkedList.SingleLink{
-                 value: 3,
-                 reference: nil
-               }
-             ]
+      node = %Node{value: 3, reference: nil}
+      result = %SinglyLinkedList.LinkedList{nodes: [node]}
+      add_node_head_result = SinglyLinkedList.add_node_head(%LinkedList{nodes: []}, 3)
+      assert add_node_head_result == result
+      assert SinglyLinkedList.list_length(add_node_head_result) == 1
+      assert SinglyLinkedList.tail(add_node_head_result) == %Node{value: 3, reference: nil}
     end
 
     test "it adds to the head" do
       list =
-        SinglyLinkedList.add_node([], 3)
-        |> SinglyLinkedList.add_node(4)
-        |> SinglyLinkedList.add_node(5)
-
-      assert list == [
-               %Algorithims.DataStructures.SinglyLinkedList.SingleLink{
-                 reference: %Algorithims.DataStructures.SinglyLinkedList.SingleLink{
-                   reference: %Algorithims.DataStructures.SinglyLinkedList.SingleLink{
-                     reference: nil,
-                     value: 3
-                   },
-                   value: 4
-                 },
-                 value: 5
-               },
-               %Algorithims.DataStructures.SinglyLinkedList.SingleLink{
-                 reference: %Algorithims.DataStructures.SinglyLinkedList.SingleLink{
-                   reference: nil,
-                   value: 3
-                 },
-                 value: 4
-               },
-               %Algorithims.DataStructures.SinglyLinkedList.SingleLink{reference: nil, value: 3}
-             ]
+        SinglyLinkedList.add_node_head(%LinkedList{nodes: []}, 3)
+        |> SinglyLinkedList.add_node_head(4)
+        |> SinglyLinkedList.add_node_head(5)
+        |> SinglyLinkedList.add_node_head(6)
+
+      assert SinglyLinkedList.list_length(list) == 4
+
+      assert SinglyLinkedList.head(list) == %Node{
+               value: 6,
+               reference: %Node{
+                 value: 5,
+                 reference: %Node{value: 4, reference: %Node{value: 3, reference: nil}}
+               }
+             }
+
+      assert SinglyLinkedList.tail(list) == %Node{value: 3, reference: nil}
+    end
+
+    test "it adds to the tail" do
+      list = SinglyLinkedList.add_node_tail(%LinkedList{nodes: []}, 3)
+      list = list |> SinglyLinkedList.add_node_tail(4)
+
+      assert SinglyLinkedList.list_length(list) == 2
+      assert list.nodes |> length == 2
+
+      assert SinglyLinkedList.tail(list) == %Node{value: 4, reference: nil}
+
+      assert SinglyLinkedList.head(list) == %Node{
+               value: 3,
+               reference: %Node{value: 4, reference: nil}
+             }
+
+      list =
+        list
+        |> SinglyLinkedList.add_node_tail(5)
+
+      # need to just travese list
+      # assert SinglyLinkedList.head(list) == %Node{
+      #          value: 3,
+      #          reference: %Node{
+      #            value: 4,
+      #            reference: %Node{value: 5, reference: nil}
+      #          }
+      #        }
+
+      assert SinglyLinkedList.tail(list) == %Node{
+               value: 5,
+               reference: nil
+             }
     end
   end
 end