make the linked list generic over the Node value

Author: danrusei

linkedlist/README.md

@@ -9,4 +9,3 @@ A linked list is a linear collection of data elements whose order is not given b
 The principal benefit of a linked list over a conventional array is that the list elements can be easily inserted or removed without reallocation or reorganization of the entire structure because the data items need not be stored contiguously in memory or on disk, while restructuring an array at run-time is a much more expensive operation. Linked lists allow insertion and removal of nodes at any point in the list, and allow doing so with a constant number of operations by keeping the link previous to the link being added or removed in memory during list traversal.
 
 This module serves as the base for all executable. So we don't have to redefine the Node, Linkedlist and the basic methods while solving the problems.
-

linkedlist/compare_strings/compare.go

@@ -1,6 +1,6 @@
 package compare
 
-func compareStrings(list1 *Linkedlist, list2 *Linkedlist) int {
+func compareStrings(list1 *llist, list2 *llist) int {
 	// remember that the list is defines as:
 	// type Linkedlist struct {
 	//  	Length int
@@ -17,14 +17,15 @@ func compareStrings(list1 *Linkedlist, list2 *Linkedlist) int {
 
 	cur1 := list1.Head
 	cur2 := list2.Head
-	for cur1.Val == cur2.Val && cur1.Next != nil {
+	// type assertion is required as the Node value = interface{}
+	for cur1.Val.(string) == cur2.Val.(string) && cur1.Next != nil {
 		cur1 = cur1.Next
 		cur2 = cur2.Next
 	}
 
-	if cur1.Val > cur2.Val {
+	if cur1.Val.(string) > cur2.Val.(string) {
 		return 1
-	} else if cur1.Val < cur2.Val {
+	} else if cur1.Val.(string) < cur2.Val.(string) {
 		return -1
 	}
 	//asumes the list are equal

linkedlist/compare_strings/compare_test.go

@@ -2,25 +2,31 @@ package compare
 
 import (
 	"testing"
+
+	"github.com/danrusei/algorithms_with_go/linkedlist"
 )
 
+type llist struct {
+	linkedlist.Linkedlist
+}
+
 // this function creates the lists,
 // the way the linkedlist is defined it allows us to check the length
-func createLinkedList(vals []string) *Linkedlist {
-	list := NewLinkedlist()
-	node := NewNode(vals[0])
+func createLinkedList(vals []string) *llist {
+	list := llist{}
+	node := linkedlist.NewNode(vals[0])
 	list.Head = node
 	list.Length = 1
 	cur := list.Head
 	for i, val := range vals {
 		if i == 0 {
 			continue
 		}
-		node := NewNode(val)
+		node := linkedlist.NewNode(val)
 		cur.Next = node
 		list.Length++
 	}
-	return list
+	return &list
 }
 
 func TestComparedStrings(t *testing.T) {

linkedlist/compare_strings/linked_list.go

@@ -14,7 +14,8 @@ type llist struct {
 func (ll *llist) sortedInsert(n *linkedlist.Node) {
 
 	//special case for the head end
-	if ll.Head == nil || ll.Head.Val >= n.Val {
+	// type assertion is required as the Linked List value = interface{}
+	if ll.Head == nil || ll.Head.Val.(int) >= n.Val.(int) {
 		n.Next = ll.Head
 		ll.Head = n
 		ll.Length++
@@ -23,7 +24,7 @@ func (ll *llist) sortedInsert(n *linkedlist.Node) {
 
 	//locate the node before the point of insertion
 	cur := ll.Head
-	for ; cur.Next != nil && cur.Next.Val < n.Val; cur = cur.Next {
+	for ; cur.Next != nil && cur.Next.Val.(int) < n.Val.(int); cur = cur.Next {
 	}
 	n.Next = cur.Next
 	cur.Next = n

linkedlist/insert_node/main.go

@@ -12,8 +12,13 @@ package linkedlist
 import "fmt"
 
 // Node struct holds a node
+// the value of the Node could be anything (int, string or a struncture)
+// interface{} - an empty interface may hold values of any type.
+// if using interface{} confuse you, change with any type you would like
+// initially I started with int value, but some problems require strings as values 
+// another example: implementing Hash-Table I need even to define a Key-Value struct
 type Node struct {
-	Val  int
+	Val  interface{}
 	Next *Node
 }
 
@@ -29,7 +34,7 @@ func NewLinkedlist() *Linkedlist {
 }
 
 // NewNode creates a new node
-func NewNode(val int) *Node {
+func NewNode(val interface{}) *Node {
 	return &Node{val, nil}
 }
 
@@ -38,14 +43,14 @@ func (ll *Linkedlist) String() string {
 	cur := ll.Head
 	var printedlist string
 	for ; cur.Next != nil; cur = cur.Next {
-		printedlist = printedlist + fmt.Sprintf("%d \t", cur.Val)
+		printedlist = printedlist + fmt.Sprintf("%v \t", cur.Val)
 	}
-	printedlist = printedlist + fmt.Sprintf("%d", cur.Val)
+	printedlist = printedlist + fmt.Sprintf("%v", cur.Val)
 	return printedlist
 }
 
 //AddAtBeg adds a Node at the beginning of the list
-func (ll *Linkedlist) AddAtBeg(val int) {
+func (ll *Linkedlist) AddAtBeg(val interface{}) {
 	n := NewNode(val)
 	n.Next = ll.Head
 	ll.Head = n
@@ -54,7 +59,7 @@ func (ll *Linkedlist) AddAtBeg(val int) {
 }
 
 //AddAtEnd adds a Node at the end of the list
-func (ll *Linkedlist) AddAtEnd(val int) {
+func (ll *Linkedlist) AddAtEnd(val interface{}) {
 	n := NewNode(val)
 
 	if ll.Head == nil {
@@ -72,7 +77,7 @@ func (ll *Linkedlist) AddAtEnd(val int) {
 }
 
 //DelAtBeg deletes a node from the beginning of the list
-func (ll *Linkedlist) DelAtBeg() int {
+func (ll *Linkedlist) DelAtBeg() interface{} {
 	if ll.Head == nil {
 		return -1
 	}
@@ -84,7 +89,7 @@ func (ll *Linkedlist) DelAtBeg() int {
 }
 
 //DelAtEnd deletes a node from the end of the list
-func (ll *Linkedlist) DelAtEnd() int {
+func (ll *Linkedlist) DelAtEnd() interface{} {
 	if ll.Head == nil {
 		return -1
 	}
@@ -101,7 +106,7 @@ func (ll *Linkedlist) DelAtEnd() int {
 }
 
 //DeleteWithValute deletes a node which value is equal to the function parameter
-func (ll *Linkedlist) DeleteWithValute(val int) int {
+func (ll *Linkedlist) DeleteWithValute(val interface{}) interface{} {
 	if ll.Head == nil {
 		return -1
 	}

linkedlist/linkedlist.go

@@ -15,10 +15,10 @@ func TestLinkedList(t *testing.T) {
 		want := []int{3, 2, 1}
 		got := []int{}
 		current := list.Head
-		got = append(got, current.Val)
+		got = append(got, current.Val.(int))
 		for current.Next != nil {
 			current = current.Next
-			got = append(got, current.Val)
+			got = append(got, current.Val.(int))
 		}
 		if !reflect.DeepEqual(got, want) {
 			t.Errorf("got: %v, want: %v", got, want)
@@ -31,10 +31,10 @@ func TestLinkedList(t *testing.T) {
 		want := []int{3, 2, 1, 4}
 		got := []int{}
 		current := list.Head
-		got = append(got, current.Val)
+		got = append(got, current.Val.(int))
 		for current.Next != nil {
 			current = current.Next
-			got = append(got, current.Val)
+			got = append(got, current.Val.(int))
 		}
 		if !reflect.DeepEqual(got, want) {
 			t.Errorf("got: %v, want: %v", got, want)

linkedlist/linkedlist_test.go

@@ -37,7 +37,8 @@ func (ll *llist) randomNode() int {
 		n++
 	}
 
-	return result
+	// type assertion is required because Linked List value = interface{}
+	return result.(int)
 }
 
 func main() {