linkedlist

Author: mstgnz

examples/linkedlist/linkedlist_examples.go

@@ -8,93 +8,164 @@ import (
 )
 
 func main() {
-	// Linear Linked List örnekleri
-	fmt.Println("Linear Linked List Örnekleri:")
+	fmt.Println("=== Linear Linked List Examples ===")
+	linearListExamples()
 
-	// Integer List
-	intLinear := linkedlist.NewLinear[int](10)
-	intLinear.AddToEnd(20)
-	intLinear.AddToEnd(30)
+	fmt.Println("\n=== Double Linked List Examples ===")
+	doubleListExamples()
+
+	fmt.Println("\n=== Circular Linked List Examples ===")
+	circularListExamples()
+
+	fmt.Println("\n=== Custom Type Examples ===")
+	customTypeExamples()
+}
+
+func linearListExamples() {
+	// Create a new Linear List with integers
+	intList := linkedlist.NewLinear[int](10)
+
+	// Define comparison functions
 	intLess := func(a, b int) bool { return a < b }
-	intLinear.AddToSequentially(15, intLess)
-	fmt.Println("\nInteger Linear List:")
-	intLinear.Print()
+	intEquals := func(a, b int) bool { return a == b }
+
+	// Add elements sequentially
+	fmt.Println("\nAdding elements sequentially:")
+	intList.AddToSequentially(5, intLess)
+	intList.AddToSequentially(15, intLess)
+	intList.AddToSequentially(12, intLess)
+	intList.Print() // Expected: 5 10 12 15
 
-	// String List
-	strLinear := linkedlist.NewLinear[string]("Merhaba")
-	strLinear.AddToEnd("Dünya")
+	// Add element after a specific value
+	fmt.Println("\nAdding 13 after 12:")
+	intList.AddToAfter(13, 12, intEquals)
+	intList.Print() // Expected: 5 10 12 13 15
+
+	// Search for elements
+	fmt.Printf("\nSearch for 12: %v\n", intList.Search(12, intEquals))
+	fmt.Printf("Search for 99: %v\n", intList.Search(99, intEquals))
+
+	// Delete elements
+	fmt.Println("\nDeleting 12:")
+	intList.Delete(12, intEquals)
+	intList.Print()
+
+	// Create a Linear List with strings
+	strList := linkedlist.NewLinear[string]("Hello")
+
+	// Define string comparison functions
 	strLess := func(a, b string) bool { return strings.Compare(a, b) < 0 }
-	strLinear.AddToSequentially("Go", strLess)
-	fmt.Println("\nString Linear List:")
-	strLinear.Print()
-
-	// Double Linked List örnekleri
-	fmt.Println("\nDouble Linked List Örnekleri:")
-
-	// Integer List
-	intDouble := linkedlist.NewDouble[int](10)
-	intDouble.AddToEnd(20)
-	intDouble.AddToEnd(30)
-	intDouble.AddToSequentially(15, intLess)
-	fmt.Println("\nInteger Double List (İleri):")
-	intDouble.Print(false)
-	fmt.Println("Integer Double List (Geri):")
-	intDouble.Print(true)
-
-	// String List
-	strDouble := linkedlist.NewDouble[string]("Merhaba")
-	strDouble.AddToEnd("Dünya")
-	strDouble.AddToSequentially("Go", strLess)
-	fmt.Println("\nString Double List (İleri):")
-	strDouble.Print(false)
-	fmt.Println("String Double List (Geri):")
-	strDouble.Print(true)
-
-	// Circular Linked List örnekleri
-	fmt.Println("\nCircular Linked List Örnekleri:")
-
-	// Integer List
-	intCircular := linkedlist.NewCircular[int](10)
-	intCircular.AddToEnd(20)
-	intCircular.AddToEnd(30)
-	intCircular.AddToSequentially(15, intLess)
-	fmt.Println("\nInteger Circular List:")
-	intCircular.Print()
-
-	// String List
-	strCircular := linkedlist.NewCircular[string]("Merhaba")
-	strCircular.AddToEnd("Dünya")
-	strCircular.AddToSequentially("Go", strLess)
-	fmt.Println("\nString Circular List:")
-	strCircular.Print()
-
-	// Custom struct örneği
+	strEquals := func(a, b string) bool { return a == b }
+
+	fmt.Println("\nString List Operations:")
+	strList.AddToSequentially("World", strLess)
+	strList.AddToSequentially("Go", strLess)
+	strList.Print() // Expected: Go Hello World
+
+	// Search and delete operations with strings
+	fmt.Printf("Search for 'Hello': %v\n", strList.Search("Hello", strEquals))
+	strList.Delete("Hello", strEquals)
+	strList.Print()
+}
+
+func doubleListExamples() {
+	// Create a new Double List with integers
+	intList := linkedlist.NewDouble[int](10)
+
+	// Define comparison functions
+	intLess := func(a, b int) bool { return a < b }
+	intEquals := func(a, b int) bool { return a == b }
+
+	// Add elements sequentially
+	fmt.Println("\nAdding elements sequentially:")
+	intList.AddToSequentially(5, intLess)
+	intList.AddToSequentially(15, intLess)
+	intList.AddToSequentially(12, intLess)
+
+	// Print forward and backward
+	fmt.Println("Forward traversal:")
+	intList.Print(false)
+	fmt.Println("Backward traversal:")
+	intList.Print(true)
+
+	// Add element after a specific value
+	fmt.Println("\nAdding 13 after 12:")
+	intList.AddToAfter(13, 12, intEquals)
+	intList.Print(false)
+
+	// Delete elements
+	fmt.Println("\nDeleting 12:")
+	intList.Delete(12, intEquals)
+	intList.Print(false)
+}
+
+func circularListExamples() {
+	// Create a new Circular List with integers
+	intList := linkedlist.NewCircular[int](10)
+
+	// Define comparison functions
+	intLess := func(a, b int) bool { return a < b }
+	intEquals := func(a, b int) bool { return a == b }
+
+	// Add elements sequentially
+	fmt.Println("\nAdding elements sequentially:")
+	intList.AddToSequentially(5, intLess)
+	intList.AddToSequentially(15, intLess)
+	intList.AddToSequentially(12, intLess)
+	intList.Print()
+
+	// Add element after a specific value
+	fmt.Println("\nAdding 13 after 12:")
+	intList.AddToAfter(13, 12, intEquals)
+	intList.Print()
+
+	// Delete elements
+	fmt.Println("\nDeleting 12:")
+	intList.Delete(12, intEquals)
+	intList.Print()
+}
+
+func customTypeExamples() {
+	// Define a custom type
 	type Person struct {
 		Name string
 		Age  int
 	}
 
-	// Person karşılaştırma fonksiyonları
+	// Create comparison functions for Person type
 	personLess := func(a, b Person) bool { return a.Age < b.Age }
+	personEquals := func(a, b Person) bool {
+		return a.Name == b.Name && a.Age == b.Age
+	}
 
-	// Linear List with Person
-	personLinear := linkedlist.NewLinear[Person](Person{Name: "Ali", Age: 25})
-	personLinear.AddToEnd(Person{Name: "Ayşe", Age: 30})
-	personLinear.AddToSequentially(Person{Name: "Mehmet", Age: 28}, personLess)
-	fmt.Println("\nPerson Linear List:")
-	personLinear.Print()
-
-	// Double List with Person
-	personDouble := linkedlist.NewDouble[Person](Person{Name: "Ali", Age: 25})
-	personDouble.AddToEnd(Person{Name: "Ayşe", Age: 30})
-	personDouble.AddToSequentially(Person{Name: "Mehmet", Age: 28}, personLess)
-	fmt.Println("\nPerson Double List:")
-	personDouble.Print(false)
-
-	// Circular List with Person
-	personCircular := linkedlist.NewCircular[Person](Person{Name: "Ali", Age: 25})
-	personCircular.AddToEnd(Person{Name: "Ayşe", Age: 30})
-	personCircular.AddToSequentially(Person{Name: "Mehmet", Age: 28}, personLess)
-	fmt.Println("\nPerson Circular List:")
-	personCircular.Print()
+	// Create lists of different types with Person
+	linearList := linkedlist.NewLinear[Person](Person{Name: "Alice", Age: 25})
+	doubleList := linkedlist.NewDouble[Person](Person{Name: "Bob", Age: 30})
+	circularList := linkedlist.NewCircular[Person](Person{Name: "Charlie", Age: 35})
+
+	// Add elements to Linear List
+	fmt.Println("\nLinear List with Person type:")
+	linearList.AddToSequentially(Person{Name: "David", Age: 20}, personLess)
+	linearList.AddToSequentially(Person{Name: "Eve", Age: 28}, personLess)
+	linearList.Print()
+
+	// Search and delete operations with Person type
+	searchPerson := Person{Name: "David", Age: 20}
+	fmt.Printf("Search for %v: %v\n", searchPerson, linearList.Search(searchPerson, personEquals))
+	linearList.Delete(searchPerson, personEquals)
+	linearList.Print()
+
+	// Add elements to Double List
+	fmt.Println("\nDouble List with Person type:")
+	doubleList.AddToSequentially(Person{Name: "Frank", Age: 22}, personLess)
+	doubleList.AddToSequentially(Person{Name: "Grace", Age: 33}, personLess)
+	doubleList.Print(false)
+	fmt.Println("Backward traversal:")
+	doubleList.Print(true)
+
+	// Add elements to Circular List
+	fmt.Println("\nCircular List with Person type:")
+	circularList.AddToSequentially(Person{Name: "Henry", Age: 27}, personLess)
+	circularList.AddToSequentially(Person{Name: "Ivy", Age: 40}, personLess)
+	circularList.Print()
 }

linkedlist/Circular.go

@@ -35,26 +35,36 @@ func (node *Circular[T]) AddToSequentially(data T, less func(T, T) bool) {
 	node.mutex.Lock()
 	defer node.mutex.Unlock()
 
-	iter := node
-	// If the value to be added is less than the value of the root object
-	if less(data, node.X) {
-		temp := node.X
-		node.X = data
-		newNode := &Circular[T]{X: temp, Next: node.Next}
-		node.Next = newNode
+	// Handle the first node
+	if node.Next == node || less(data, node.X) {
+		if less(data, node.X) {
+			temp := node.X
+			node.X = data
+			newNode := &Circular[T]{X: temp, Next: node.Next, mutex: sync.RWMutex{}}
+			node.Next = newNode
+		} else {
+			newNode := &Circular[T]{X: data, Next: node, mutex: sync.RWMutex{}}
+			node.Next = newNode
+		}
+
+		// Update the last node to point to the head
+		iter := node
 		for iter.Next != node {
 			iter = iter.Next
 		}
 		iter.Next = node
-	} else {
-		// Advance up to the value that is less than the value you want to add.
-		for iter.Next != node && less(iter.Next.X, data) {
-			iter = iter.Next
-		}
-		// Add the value to the next of the object that is smaller than the value to be added, by creating a new object.
-		// add the current next to the next of the newly added object
-		iter.Next = &Circular[T]{X: data, Next: iter.Next}
+		return
 	}
+
+	// Find the correct position to insert
+	iter := node
+	for iter.Next != node && !less(data, iter.Next.X) {
+		iter = iter.Next
+	}
+
+	// Insert the new node
+	newNode := &Circular[T]{X: data, Next: iter.Next, mutex: sync.RWMutex{}}
+	iter.Next = newNode
 }
 
 // AddToAfter adds data after the specified value

linkedlist/Circular_test.go

@@ -43,51 +43,51 @@ func TestCircular_New(t *testing.T) {
 
 func TestCircular_AddToSequentially(t *testing.T) {
 	tests := []struct {
-		name string
-		init int
-		add  []int
-		want []int
+		name     string
+		init     int
+		add      []int
+		expected []int
 	}{
 		{
-			name: "add sequentially to empty list",
-			init: 0,
-			add:  []int{1},
-			want: []int{0, 1},
+			name:     "add sequentially to empty list",
+			init:     0,
+			add:      []int{1},
+			expected: []int{0, 1},
 		},
 		{
-			name: "add sequentially multiple items",
-			init: 1,
-			add:  []int{2, 3, 4},
-			want: []int{1, 2, 3, 4},
+			name:     "add sequentially multiple items",
+			init:     1,
+			add:      []int{2, 3, 4},
+			expected: []int{1, 2, 3, 4},
 		},
 		{
-			name: "add sequentially with duplicates",
-			init: 1,
-			add:  []int{2, 2, 3},
-			want: []int{1, 2, 2, 3},
+			name:     "add sequentially with duplicates",
+			init:     1,
+			add:      []int{2, 2, 3},
+			expected: []int{1, 2, 2, 3},
 		},
 		{
-			name: "add sequentially with negative numbers",
-			init: 0,
-			add:  []int{-2, -1, 1},
-			want: []int{-2, -1, 0, 1},
+			name:     "add sequentially with negative numbers",
+			init:     0,
+			add:      []int{-2, -1, 1},
+			expected: []int{-2, -1, 0, 1},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			list := NewCircular(tt.init)
 			for _, v := range tt.add {
-				list.AddToSequentially(v, func(a, b int) bool { return a == b })
+				list.AddToSequentially(v, func(a, b int) bool { return a < b })
 			}
 			got := list.List()
-			if len(got) != len(tt.want) {
-				t.Errorf("After AddToSequentially() = %v, want %v", got, tt.want)
+			if len(got) != len(tt.expected) {
+				t.Errorf("After AddToSequentially() = %v, want %v", got, tt.expected)
 				return
 			}
 			for i, v := range got {
-				if v != tt.want[i] {
-					t.Errorf("After AddToSequentially() = %v, want %v", got, tt.want)
+				if v != tt.expected[i] {
+					t.Errorf("After AddToSequentially() = %v, want %v", got, tt.expected)
 				}
 			}
 		})