linklist

package main

import (
    "fmt"
)

type Node struct { 
    value int
    next *Node
}

func NewNode(val int) Node {
     return Node{value: val, next : nil}
}

type MyLinklist struct{
    head *Node
    tail *Node
    length int
}

func NewLinklist(value int) MyLinklist {
    newNode := NewNode(value)
    return MyLinklist{ head: &newNode, tail: &newNode, length: 1}
}

func (list *MyLinklist) append(value int) MyLinklist {
    newNode := NewNode(value)
    list.tail.next = &newNode
    list.tail = &newNode
    list.length++
    return *list
}

func (list *MyLinklist) prepend(value int) MyLinklist {
    newNode := Node{value: value, next : nil}
    newNode.next = list.head
    list.head = &newNode
    list.length++
    return *list
}

func (list *MyLinklist) insert(index, value int) (MyLinklist, error) {
    if index < 0 || index > list.length {
        return *list, fmt.Errorf("invalid input index should be in 0 and %d", list.length)
    }
    
    if index == 0 {
        return list.prepend(value), nil
    } else if index == list.length {
        return list.append(value), nil
    }
    
    //get leader node at index
    leader := list.traverseToIndexNode(index-1)
    newNode := NewNode(value)
    newNode.next = leader.next
    leader.next = &newNode
    list.length++
    
    return *list, nil
}

func (list *MyLinklist) remove(index int) (MyLinklist, error) {
    if index < 0 || index > list.length {
        return *list, fmt.Errorf("invalid input index should be in 0 and %d", list.length)
    }
    if index == 0 {
        list.head = list.head.next
        return *list, nil
    } 
    
    //get leader node
    leaderNode := list.traverseToIndexNode(index-1)
    fmt.Printf("\n remove node at %d , leader is : %v", index, leaderNode)
    nodeToRemove := leaderNode.next
    leaderNode.next = nodeToRemove.next
   
    
    return *list, nil
}

func (list *MyLinklist) reverse() MyLinklist {
    curr := list.head
    list.tail = list.head
    var prevNode *Node
    var nextNode *Node
    for curr != nil {
        nextNode = curr.next
        curr.next = prevNode
        prevNode = curr
        curr = nextNode
    }
    
    //At last point currHead to Prev
    list.head = prevNode
    return *list
}

 //return node at index
func(list *MyLinklist) traverseToIndexNode(index int) *Node {
    idxNode := list.head
    c := 0
    for c < index {
        idxNode = idxNode.next
        c++
    }
    return idxNode
}

func(list *MyLinklist) print() {
    head := list.head
    for head != nil {
        fmt.Printf("%d \t", head.value)
        head = head.next
    }
}


func main() {
    list := NewLinklist(5)
    list.append(12)
    list.append(10)
    list.prepend(15)
    list.prepend(1)
    
    list.print()
    
    _, err := list.remove(2)
    if err != nil {
         fmt.Println("insert error: ", err)
    }
    
    fmt.Println("\nafter remove node at index 2")
    list.print()
    
    _, err = list.insert(1, 100)
    if err != nil {
         fmt.Println("insert error: ", err)
    }
    
    fmt.Printf("\nafter insert node value %d at index %d \n", 100, 1)
    list.print()
    
    list.reverse()
    fmt.Println("\n reverse list")
    list.print()
    
}