diff --git a/datastructure/link/doublylink.go b/datastructure/link/doublylink.go index a413deb..19516d4 100644 --- a/datastructure/link/doublylink.go +++ b/datastructure/link/doublylink.go @@ -87,6 +87,7 @@ func (dl *DoublyLink[T]) InsertAt(index int, value T) { newNode := datastructure.NewLinkNode(value) newNode.Next = current.Next newNode.Pre = current + current.Next.Pre = newNode current.Next = newNode dl.length++ @@ -106,7 +107,9 @@ func (dl *DoublyLink[T]) DeleteAtHead() { current := dl.Head dl.Head = current.Next - dl.Head.Pre = nil + if dl.Head != nil { + dl.Head.Pre = nil + } dl.length-- } @@ -119,6 +122,7 @@ func (dl *DoublyLink[T]) DeleteAtTail() { current := dl.Head if current.Next == nil { dl.DeleteAtHead() + return } for current.Next.Next != nil { @@ -132,27 +136,26 @@ func (dl *DoublyLink[T]) DeleteAtTail() { // DeleteAt delete value in doubly linklist at index // param `index` should be [0, len(DoublyLink)-1] func (dl *DoublyLink[T]) DeleteAt(index int) { - if dl.Head == nil { + if dl.Head == nil || index < 0 || index >= dl.length { return } - current := dl.Head - if current.Next == nil || index == 0 { + if index == 0 { dl.DeleteAtHead() + return } if index == dl.length-1 { dl.DeleteAtTail() - } - - if index < 0 || index > dl.length-1 { return } + current := dl.Head i := 0 for current != nil { if i == index-1 { current.Next = current.Next.Next + current.Next.Pre = current dl.length-- return } diff --git a/datastructure/link/mutation_boundaries_test.go b/datastructure/link/mutation_boundaries_test.go new file mode 100644 index 0000000..a30da85 --- /dev/null +++ b/datastructure/link/mutation_boundaries_test.go @@ -0,0 +1,115 @@ +package datastructure + +import ( + "reflect" + "testing" +) + +type mutableIntLink interface { + InsertAtHead(int) + InsertAtTail(int) + DeleteAtHead() + DeleteAtTail() + DeleteAt(int) + Reverse() + Values() []int + Size() int + IsEmpty() bool +} + +func TestLinkDeletionBoundaries(t *testing.T) { + for name, newLink := range map[string]func() mutableIntLink{ + "singly": func() mutableIntLink { return NewSinglyLink[int]() }, + "doubly": func() mutableIntLink { return NewDoublyLink[int]() }, + } { + t.Run(name, func(t *testing.T) { + for _, tt := range []struct { + name string + size int + delete func(mutableIntLink) + want []int + }{ + {"empty head", 0, func(l mutableIntLink) { l.DeleteAtHead() }, []int{}}, + {"empty tail", 0, func(l mutableIntLink) { l.DeleteAtTail() }, []int{}}, + {"empty index", 0, func(l mutableIntLink) { l.DeleteAt(0) }, []int{}}, + {"singleton head", 1, func(l mutableIntLink) { l.DeleteAtHead() }, []int{}}, + {"singleton tail", 1, func(l mutableIntLink) { l.DeleteAtTail() }, []int{}}, + {"singleton index", 1, func(l mutableIntLink) { l.DeleteAt(0) }, []int{}}, + {"singleton negative index", 1, func(l mutableIntLink) { l.DeleteAt(-1) }, []int{1}}, + {"singleton large index", 1, func(l mutableIntLink) { l.DeleteAt(1) }, []int{1}}, + {"two item head index", 2, func(l mutableIntLink) { l.DeleteAt(0) }, []int{2}}, + {"two item tail index", 2, func(l mutableIntLink) { l.DeleteAt(1) }, []int{1}}, + {"middle index", 4, func(l mutableIntLink) { l.DeleteAt(1) }, []int{1, 3, 4}}, + {"tail index", 4, func(l mutableIntLink) { l.DeleteAt(3) }, []int{1, 2, 3}}, + {"negative index", 4, func(l mutableIntLink) { l.DeleteAt(-1) }, []int{1, 2, 3, 4}}, + {"large index", 4, func(l mutableIntLink) { l.DeleteAt(4) }, []int{1, 2, 3, 4}}, + } { + t.Run(tt.name, func(t *testing.T) { + defer func() { + if value := recover(); value != nil { + t.Errorf("list mutation panicked: %v", value) + } + }() + l := newLink() + for i := 1; i <= tt.size; i++ { + l.InsertAtTail(i) + } + tt.delete(l) + if got := l.Values(); !reflect.DeepEqual(got, tt.want) { + t.Fatalf("Values() = %v, want %v", got, tt.want) + } + if l.Size() != len(tt.want) || l.IsEmpty() != (len(tt.want) == 0) { + t.Fatalf("Size() = %d, IsEmpty() = %v, want length %d", l.Size(), l.IsEmpty(), len(tt.want)) + } + if doubly, ok := l.(*DoublyLink[int]); ok { + current := doubly.Head + for i := 0; current != nil; i++ { + if i >= l.Size() { + t.Fatal("cycle in list after deletion") + } + if current.Next != nil && current.Next.Pre != current { + t.Fatal("deletion did not preserve reciprocal links") + } + current = current.Next + } + } + l.Reverse() + wantReverse := make([]int, len(tt.want)) + for i, value := range tt.want { + wantReverse[len(tt.want)-1-i] = value + } + if got := l.Values(); !reflect.DeepEqual(got, wantReverse) { + t.Fatalf("Reverse Values() = %v, want %v", got, wantReverse) + } + l.Reverse() + l.InsertAtHead(9) + if got := l.Values(); !reflect.DeepEqual(got, append([]int{9}, tt.want...)) { + t.Fatalf("reused list Values() = %v", got) + } + }) + } + }) + } +} + +func TestDoublyLinkMiddleMutationBacklinks(t *testing.T) { + l := NewDoublyLink[int]() + l.InsertAtTail(1) + l.InsertAtTail(3) + l.InsertAt(1, 2) + if l.Head.Next.Next.Pre != l.Head.Next { + t.Fatal("middle insertion did not update the next node's Pre link") + } + l.Reverse() + if got := l.Values(); !reflect.DeepEqual(got, []int{3, 2, 1}) { + t.Fatalf("Reverse() after insertion = %v", got) + } + l.DeleteAt(1) + if l.Head.Next.Pre != l.Head { + t.Fatal("middle deletion did not update the next node's Pre link") + } + l.Reverse() + if got := l.Values(); !reflect.DeepEqual(got, []int{1, 3}) { + t.Fatalf("Reverse() after deletion = %v", got) + } +} diff --git a/datastructure/link/singlylink.go b/datastructure/link/singlylink.go index 790cdd9..eb8fb31 100644 --- a/datastructure/link/singlylink.go +++ b/datastructure/link/singlylink.go @@ -103,6 +103,7 @@ func (sl *SinglyLink[T]) DeleteAtTail() { current := sl.Head if current.Next == nil { sl.DeleteAtHead() + return } for current.Next.Next != nil { @@ -116,22 +117,20 @@ func (sl *SinglyLink[T]) DeleteAtTail() { // DeleteAt delete value in singly linklist at index // param `index` should be [0, len(SinglyLink)-1] func (sl *SinglyLink[T]) DeleteAt(index int) { - if sl.Head == nil { + if sl.Head == nil || index < 0 || index >= sl.length { return } - current := sl.Head - if current.Next == nil || index == 0 { + if index == 0 { sl.DeleteAtHead() + return } if index == sl.length-1 { sl.DeleteAtTail() - } - - if index < 0 || index > sl.length-1 { return } + current := sl.Head i := 0 for current != nil { if i == index-1 {