package main
import (
"fmt"
)
type LinkedList struct {
first, last *node
}
type node struct {
item int
next *node
}
func (l *LinkedList) add (val int) {
n := node {
item: val,
next: nil,
}
if l.first == nil {
l.last = &n
l.first = &n
} else {
l.last.next = &n
l.last = &n
}
}
func (l *LinkedList) traverse () {
for n := l.first; n != nil; n = n.next {
fmt.Printf("%v ", n.item)
}
fmt.Println()
}
func (l *LinkedList) swapLL () {
if l.first == nil {
panic("First element cannot be null")
}
if l.first.next == nil {
return
}
ptr1 := l.first
var ptr2 *node
var ptr3 *node
var prev *node
for ; ptr1 != nil && ptr1.next != nil; {
//Allocate resources
ptr2 = ptr1.next
ptr3 = ptr2.next
//swap
ptr2.next = ptr1
ptr1.next = ptr3
//hook to the previous pair
if prev == nil {
l.first = ptr2
} else {
prev.next = ptr2
}
//advance
prev = ptr1
ptr1 = ptr3
}
}
func main () {
l := LinkedList {
first: nil,
last: nil,
}
l.add(10)
l.add(20)
l.add(30)
l.add(40)
l.traverse()
l.swapLL()
l.traverse()
}
Input:
Linkedlist: 10 -> 20 -> 30 -> 40 -> null
Output:
Linkedlist: 20 -> 10 -> 40 -> 30 -> null
Question:
Here 10 and 20 are adjacent thus they were swapped. Likewise, 30 and 40 are adjacent thus they were swapped.
I am looking for suggestions for improving my code, any optimizations, or anything to make my code more readable and elegant.