206. Reverse Linked List

Author: maxvoronov

README.md

@@ -1,6 +1,6 @@
 # LeetCode
 
-![Problems Solved](https://img.shields.io/badge/Problems%20Solved-33%20%2F%203031-1f425f?logo=leetcode)
+![Problems Solved](https://img.shields.io/badge/Problems%20Solved-34%20%2F%203031-1f425f?logo=leetcode)
 ![Language: Golang](https://img.shields.io/badge/language-Golang-00ADD8?logo=go)
 ![Language: Rust](https://img.shields.io/badge/language-Rust-00ADD8?logo=rust)
 ![Language: Bash](https://img.shields.io/badge/language-Bash-00ADD8?logo=gnubash&logoColor=f5f5f5)
@@ -28,6 +28,7 @@
 |  125 | [Valid Palindrome](https://leetcode.com/problems/valid-palindrome/)                                                                   | [Go](go/0125_valid_palindrome)                                                  |     🟢     |            String, Pointer             |
 |  136 | [Single Number](https://leetcode.com/problems/single-number/)                                                                         | [Go](go/0136_single_number)                                                     |     🟢     |        Array, Bit Manipulation         |
 |  155 | [Min Stack](https://leetcode.com/problems/min-stack/)                                                                                 | [Go](go/0155_min_stack)                                                         |     🟢     |                 Stack                  |
+|  206 | [Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/)                                                             | [Go](go/0206_reverse_linked_list)                                               |     🟢     |          Linked List, Pointer          |
 |  217 | [Contains Duplicate](https://leetcode.com/problems/contains-duplicate/)                                                               | [Go](go/0217_contains_duplicate)                                                |     🟢     |           Array, Hash Table            |
 |  226 | [Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/)                                                               | [Go](go/0226_invert_binary_tree)                                                |     🟢     |      Tree, BFS, DFS, Binary Tree       |
 |  242 | [Valid Anagram](https://leetcode.com/problems/valid-anagram/)                                                                         | [Go](go/0242_valid_anagram)                                                     |     🟢     |           Hash Table, String           |

go/0206_reverse_linked_list/listnode.go

@@ -0,0 +1,28 @@
+package reverse_linked_list
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+// ToSlice convert linked list to slice (only for tests)
+func (n *ListNode) ToSlice() []int {
+	node := n
+	result := make([]int, 0)
+	for node != nil {
+		result = append(result, node.Val)
+		node = node.Next
+	}
+
+	return result
+}
+
+// SliceToLinkedList return head node of linked list (only for tests)
+func SliceToLinkedList(data []int) *ListNode {
+	var node *ListNode
+	for i := len(data) - 1; i >= 0; i-- {
+		node = &ListNode{Val: data[i], Next: node}
+	}
+
+	return node
+}

go/0206_reverse_linked_list/solution.go

@@ -0,0 +1,15 @@
+package reverse_linked_list
+
+func reverseList(head *ListNode) *ListNode {
+	var newList, nextNode *ListNode
+	currentNode := head
+
+	for currentNode != nil {
+		nextNode = currentNode.Next
+		currentNode.Next = newList
+		newList = currentNode
+		currentNode = nextNode
+	}
+
+	return newList
+}

go/0206_reverse_linked_list/solution_test.go

@@ -0,0 +1,25 @@
+package reverse_linked_list
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestReverseList(t *testing.T) {
+	tests := []struct {
+		input []int
+		want  []int
+	}{
+		{input: []int{1, 2, 3, 4, 5}, want: []int{5, 4, 3, 2, 1}},
+		{input: []int{1, 2}, want: []int{2, 1}},
+		{input: []int{}, want: []int{}},
+		{input: []int{9, 9, 9, 9, 9}, want: []int{9, 9, 9, 9, 9}},
+	}
+
+	for i, tc := range tests {
+		got := reverseList(SliceToLinkedList(tc.input))
+		if !reflect.DeepEqual(tc.want, got.ToSlice()) {
+			t.Fatalf("Case #%d: expected: %v, got: %v", i+1, tc.want, got.ToSlice())
+		}
+	}
+}