Implementing LinkedList Operations

linkedlist.go

package main

import (
	"fmt"
)


type LinkedList struct {
  Elements *LinkedList
	Head     *Node
	Size     int
}

type Node struct {
	Data int
	Next *Node
}

func NewNode(data int) *Node {
	return &Node{Data: data, Next: nil }
}

func NewLinkedList() *LinkedList {
	return &LinkedList{
		Head:     nil,
		Size:     0,
	}
}

func (ll *LinkedList) GetSize() int {
	return ll.Size
}

func (ll *LinkedList) IsEmpty() bool {
	return ll.Size == 0
}



func (ll *LinkedList) InsertAtHead(data int) *LinkedList {
	currentHead := ll.Head
  newNode := NewNode(data)
  
  // if the size of the ll is zero and head is not nil 
  if currentHead == nil || ll.Size == 0 {
    currentHead = newNode
    ll.Size++
    ll.Head = currentHead
    return ll
  }


  newNode.Next = currentHead
  currentHead = newNode 
  ll.Size++
  
  ll.Head = currentHead
  
  return ll
}


func (ll *LinkedList) InsertAtTail(data int) *LinkedList {
	//we traverse towards the end 

  newNode := NewNode(data)
  head := ll.Head 
  
  currentHead, prev := ll.Head, ll.Head 
  
  if currentHead == nil {
    currentHead = NewNode(data)
    ll.Size++
    
    ll.Head = currentHead 
    return ll 
  }

  for currentHead != nil {
    prev = currentHead
    currentHead = currentHead.Next
  }
  
  prev.Next = newNode
  ll.Size++

  ll.Head = head 
  
  return ll
}



func (ll *LinkedList) Delete(data int) *LinkedList {
  head := ll.Head
  prev := ll.Head
  current := ll.Head

  if ll.Size == 0 {
    return ll 
  }

  // check if the first data is the data to be removed
  if current.Data == data {
    newCurrent := current.Next  //points to the next node 
    
    current.Next = nil // delete the current node 
    current = newCurrent //change current pointer to the next node 
    prev = current 
    


    ll.Head = current  
    ll.Size--
    
    return ll 
  }
  
  for current != nil && current.Data != data {
    prev = current 
    current = current.Next
  }
  prev.Next = current.Next
  current = current.Next  

  ll.Head = head 
  ll.Size--
  
  
  return ll 
}


func (ll *LinkedList) Print() {
  head := ll.Head
  current := ll.Head 
  
  for current != nil {
    fmt.Printf("%d ", current.Data)
    current = current.Next
  }
  
  fmt.Println()
  ll.Head = head 
}

// TODO: Remove this
func mergeTwoList(l1 *Node, l2 *Node) *LinkedList {
  l1Arr := spliceList(l1)
  l2Arr := spliceList(l2)

  ll := NewLinkedList()

  if len(l1Arr) == len(l2Arr) {
    
    c1, f1 := l1, l1  
    c2, f2:= l2, l2 
    
    for c1 != nil && c2 != nil {  
      f1 = c1.Next 
      f2 = c2.Next 

      ll.InsertAtHead(c1.Data)
      ll.InsertAtHead(c2.Data)
      
      c1 = f1 
      c2 = f2
    }
  }

  return ll
}

func spliceList(ll *Node) []int {
  var arr []int 

  for ll != nil {
    arr = append(arr, ll.Data)
    ll = ll.Next
  }
  return arr 
}

func main() {
	l1 := NewLinkedList()
  l2 := NewLinkedList()

  l1.InsertAtTail(1).InsertAtTail(40).InsertAtTail(50).InsertAtTail(70).InsertAtTail(120)
  l2.InsertAtTail(1).InsertAtTail(340).InsertAtTail(550).InsertAtTail(670).InsertAtTail(920)

  ll := mergeTwoList(l1.Head, l2.Head)
  ll.Print()
}