Delete the Middle Node of a Linked List

Author: volodimyr

2095.delete_the_mid_node_of_linked_list/delete.go

@@ -0,0 +1,63 @@
+// 2095. Delete the middle node of a linked list
+// Topics: 'Linked List', 'Two Pointers'
+
+// You are given the head of a linked list. Delete the middle node, and return the head of the modified linked list.
+
+// The middle node of a linked list of size n is the ⌊n / 2⌋th node from the start using 0-based indexing, where ⌊x⌋ denotes the largest integer less than or equal to x.
+
+//     For n = 1, 2, 3, 4, and 5, the middle nodes are 0, 1, 1, 2, and 2, respectively.
+
+// Example 1:
+
+// Input: head = [1,3,4,7,1,2,6]
+// Output: [1,3,4,1,2,6]
+// Explanation:
+// The above figure represents the given linked list. The indices of the nodes are written below.
+// Since n = 7, node 3 with value 7 is the middle node, which is marked in red.
+// We return the new list after removing this node.
+
+// Example 2:
+
+// Input: head = [1,2,3,4]
+// Output: [1,2,4]
+// Explanation:
+// The above figure represents the given linked list.
+// For n = 4, node 2 with value 3 is the middle node, which is marked in red.
+
+// Example 3:
+
+// Input: head = [2,1]
+// Output: [2]
+// Explanation:
+// The above figure represents the given linked list.
+// For n = 2, node 1 with value 1 is the middle node, which is marked in red.
+// Node 0 with value 2 is the only node remaining after removing node 1.
+
+// Constraints:
+
+//     The number of nodes in the list is in the range [1, 105].
+//     1 <= Node.val <= 105
+
+package deletethemidnodeoflinkedlist
+
+func deleteMiddle(head *ListNode) *ListNode {
+	if head.Next == nil {
+		return head.Next
+	}
+	slow := head
+	fast := head
+	for {
+		fast = fast.Next.Next
+		if fast == nil || fast.Next == nil {
+			break
+		}
+		slow = slow.Next
+	}
+	slow.Next = slow.Next.Next
+	return head
+}
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}

2095.delete_the_mid_node_of_linked_list/delete_test.go

@@ -0,0 +1,95 @@
+package deletethemidnodeoflinkedlist
+
+import (
+	"testing"
+)
+
+func TestDeleteMiddle(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []int
+		expected []int
+	}{
+		{
+			name:     "seven nodes",
+			input:    []int{1, 3, 4, 7, 1, 2, 6},
+			expected: []int{1, 3, 4, 1, 2, 6},
+		},
+		{
+			name:     "four nodes",
+			input:    []int{1, 2, 3, 4},
+			expected: []int{1, 2, 4},
+		},
+		{
+			name:     "two nodes",
+			input:    []int{2, 1},
+			expected: []int{2},
+		},
+		{
+			name:     "single node",
+			input:    []int{1},
+			expected: []int{},
+		},
+		{
+			name:     "three nodes",
+			input:    []int{1, 2, 3},
+			expected: []int{1, 3},
+		},
+		{
+			name:     "five nodes",
+			input:    []int{1, 2, 3, 4, 5},
+			expected: []int{1, 2, 4, 5},
+		},
+		{
+			name:     "six nodes",
+			input:    []int{1, 2, 3, 4, 5, 6},
+			expected: []int{1, 2, 3, 5, 6},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			head := buildList(tt.input)
+			result := deleteMiddle(head)
+			actual := listToSlice(result)
+
+			if !equal(actual, tt.expected) {
+				t.Errorf("got %v, want %v", actual, tt.expected)
+			}
+		})
+	}
+}
+
+func buildList(vals []int) *ListNode {
+	if len(vals) == 0 {
+		return nil
+	}
+	head := &ListNode{Val: vals[0]}
+	current := head
+	for i := 1; i < len(vals); i++ {
+		current.Next = &ListNode{Val: vals[i]}
+		current = current.Next
+	}
+	return head
+}
+
+func listToSlice(head *ListNode) []int {
+	result := []int{}
+	for head != nil {
+		result = append(result, head.Val)
+		head = head.Next
+	}
+	return result
+}
+
+func equal(a, b []int) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}