01. Singly Linked List

Author: punit-naik

src/clj_dsa/data_structures/linked_list/singly_linked_list.clj

@@ -0,0 +1,125 @@
+(ns clj-dsa.data-structures.linked-list.singly-linked-list
+  "Singly Linked List")
+
+(definterface INode
+  (set_data [d])
+  (get_data [])
+  (set_addr [a])
+  (get_addr []))
+
+(deftype Node [^:volatile-mutable data ^:volatile-mutable addr]
+  INode
+  (set_data
+    [_ d]
+    (set! data d))
+  (get_data
+    [_]
+    data)
+  (set_addr
+    [_ a]
+    (set! addr a))
+  (get_addr
+    [_]
+    addr))
+
+(definterface ISLL
+  (set_head [h])
+  (get_head [])
+  (set_tail [t])
+  (get_tail [])
+  (print_sll [])
+  (push_front [d])
+  (push_back [d])
+  (pop_front [])
+  (pop_back [])
+  (insert [i v])
+  (search [v]))
+
+(deftype SLL [^:volatile-mutable head ^:volatile-mutable tail]
+  ISLL
+  (set_head
+    [_ h]
+    (set! head h))
+  (get_head
+    [_]
+    head)
+  (set_tail
+    [_ t]
+    (set! tail t))
+  (get_tail
+    [_]
+    tail)
+  (print_sll
+    [_]
+    (when head
+      (loop [current-head head]
+        (let [current-head-data (.get_data current-head)
+              current-head-address (.get_addr current-head)]
+          (print (str current-head-data (when current-head-address "->")))
+          (when current-head-address
+            (recur current-head-address))))))
+  (push_front
+    [this d]
+    (let [new-node (->Node d nil)]
+      (if-not head
+        (do
+          (.set_head this new-node)
+          (.set_tail this new-node))
+        (do
+          (.set_addr new-node head)
+          (.set_head this new-node)))))
+  (push_back
+    [this d]
+    (let [new-node (->Node d nil)]
+      (if-not head
+        (do
+          (.set_head this new-node)
+          (.set_tail this new-node))
+        (do
+          (.set_addr tail new-node)
+          (.set_tail this new-node)))))
+  (pop_front
+    [this]
+    (when head
+      (let [next-node (.get_addr head)]
+        (.set_head this next-node))))
+  (pop_back
+    [this]
+    (when head
+      (loop [current-head head]
+        (if-let [current-head-address (.get_addr current-head)]
+          (if (= current-head-address tail)
+            (do
+              (.set_addr current-head nil)
+              (.set_tail this current-head))
+            (recur current-head-address))
+          ;; List only has one element; remove it
+          (do
+            (.set_head this nil)
+            (.set_tail this nil))))))
+  (insert
+    [this i v]
+    (when head
+      (if (= 0 i)
+        (.push_front this v)
+        (loop [current-head head
+               index 0]
+          (if (= index (dec i))
+            ;; i.e. Found the node before the new (to be inserted) node
+            (let [new-node (->Node v (.get_addr current-head))]
+              (.set_addr current-head new-node))
+            (recur
+             (.get_addr current-head)
+             (inc index)))))))
+  (search
+    [_ v]
+    (when head
+      (loop [current-head head
+             index 0]
+        (if current-head
+          (if (= (.get_data current-head) v)
+            index
+            (recur
+             (.get_addr current-head)
+             (inc index)))
+          -1)))))

test/clj_dsa/data_structures/linked_list/singly_linked_list_test.clj

@@ -0,0 +1,64 @@
+(ns clj-dsa.data-structures.linked-list.singly-linked-list-test
+  (:require
+   [clojure.test :refer [deftest is]]
+   [clj-dsa.data-structures.linked-list.singly-linked-list :as sll]))
+
+(deftest test-node-creation
+  (let [node (sll/->Node "data" nil)]
+    (is (= "data" (.get_data node)))
+    (is (= nil (.get_addr node)))))
+
+(deftest test-set-and-get-head
+  (let [sll (sll/->SLL nil nil)
+        head-node (sll/->Node "head" nil)]
+    (.set_head sll head-node)
+    (is (= head-node (.get_head sll)))))
+
+(deftest test-set-and-get-tail
+  (let [sll (sll/->SLL nil nil)
+        tail-node (sll/->Node "tail" nil)]
+    (.set_tail sll tail-node)
+    (is (= tail-node (.get_tail sll)))))
+
+(deftest test-push-front
+  (let [sll (sll/->SLL nil nil)]
+    (.push_front sll "data1")
+    (.push_front sll "data2")
+    (is (= "data2" (.get_data (.get_head sll))))
+    (is (= "data1" (.get_data (.get_addr (.get_head sll)))))))
+
+(deftest test-push-back
+  (let [sll (sll/->SLL nil nil)]
+    (.push_back sll "data1")
+    (.push_back sll "data2")
+    (is (= "data2" (.get_data (.get_tail sll))))
+    (is (= "data1" (.get_data (.get_head sll))))))
+
+(deftest test-pop-front
+  (let [sll (sll/->SLL nil nil)]
+    (.push_back sll "head")
+    (.push_back sll "tail")
+    (.pop_front sll)
+    (is (= "tail" (.get_data (.get_head sll))))))
+
+(deftest test-pop-back
+  (let [sll (sll/->SLL nil nil)]
+    (.push_back sll "head")
+    (.push_back sll "tail")
+    (.pop_back sll)
+    (is (= "head" (.get_data (.get_head sll))))))
+
+(deftest test-insert
+  (let [sll (sll/->SLL nil nil)]
+    (.push_back sll "data1")
+    (.push_back sll "data2")
+    (.insert sll 1 "middle")
+    (is (= "middle" (.get_data (.get_addr (.get_head sll)))))))
+
+(deftest test-search
+  (let [sll (sll/->SLL nil nil)]
+    (.push_back sll "data1")
+    (.push_back sll "data2")
+    (is (= 0 (.search sll "data1")))
+    (is (= 1 (.search sll "data2")))
+    (is (= -1 (.search sll "data3")))))