Golang Reverse LinkedList

main.go

package main

import (
	"fmt"
)

type Node struct {
	Val  interface{}
	Next *Node
}

type LinkedList struct {
	Head *Node
}

func Reverse(l *LinkedList) *LinkedList {
	stack := make([]*Node, 0)
	var newHead *Node

	curr := l.Head
	for curr != nil {
		stack = append(stack, curr)
		curr = curr.Next
	}

	curr = &Node{}
	newHead = curr
	for len(stack) > 0 {
		curr.Next, stack = stack[len(stack)-1], stack[:len(stack)-1]
		curr = curr.Next
	}
	curr.Next = nil

	return &LinkedList{newHead.Next}
}

func main() {
	a := &Node{"a", nil}
	b := &Node{"b", nil}
	c := &Node{"c", nil}
	d := &Node{"d", nil}

	a.Next = b
	b.Next = c
	c.Next = d

	ll := &LinkedList{a}

	reversed := Reverse(ll)

	curr := reversed.Head
	i := 0
	for curr != nil {
		if i > 100 {
			break
		}
		i++

		fmt.Printf("%v\t", curr.Val)
		curr = curr.Next
	}
	fmt.Printf("\n")
}

main_test.go

package main

import (
	"testing"
)

func TestReversed(t *testing.T) {
	a := &Node{Val: "a", Next: nil}
	b := &Node{"b", nil}
	c := &Node{"c", nil}
	d := &Node{"d", nil}

	a.Next = b
	b.Next = c
	c.Next = d

	ll := &LinkedList{a}

	reversed := Reverse(ll)

	expected := [4]string{"d", "c", "b", "a"}
	curr := reversed.Head
	for i, v := range expected {
		if curr.Val != v {
			t.Errorf("expected value [ %s ] at position %d, got [ %s ]", v, i, curr.Val)
		}
		curr = curr.Next
	}
}