Remove Duplicates from Sorted List - Leetcode -82

I have considered 3 cases for the solution as:

• CASE 1 : If array is in form [1,2,3,4,5]
• CASE 2 : If array is in form [1,1,1,2,3,4,5]
• CASE 3 : If array is in form [1,2,3,3,3,3,4,5]

My solution in Go.

type ListNode struct {
     Val int
     Next *ListNode
}
func deleteDuplicates(head *ListNode) *ListNode {
    if head == nil || head.Next ==nil{
        return head
    }
    current := head
    var prev *ListNode
    for current.Next != nil {
        if current.Val != current.Next.Val{   // (CASE-1)
            prev = current
            current = current.Next
        } else if current ==head && current.Val == current.Next.Val {  //(CASE-2)
            current = current.Next.Next
            head = current
        } else if current != head && current.Val == current.Next.Val { //(CASE-3)
            for current.Val == current.Next.Val{
                current = current.Next
            }
            temp := current.Next
            prev = temp
            current = prev.Next
        }
    }
    return head 
}  

I am having a problem in CASE-3 ? I don't know what I am doing wrong.

You are overcomplicating your solution by solving each case separately. If you are deduplicating:

current:=head
for current.Next!=nil {
   if current.Next.Val==current.Val {
      // Remove the duplicate node, stay on the same node
      curent.Next=current.Next.Next
   } else {
     // Advance to the next node
      current=current.Next
   }
}

If you are removing all instances of duplicated values:

current:=head
var prev *ListNode
for current!=nil {
  trc:=current
  // Find the next node with a different value
  for trc!=nil {
     if trc.Val==current.Val {
        trc=trc.Next
     } else {
         break
     }
  }

  // if trc==nil, all remaining values are the same
  // if prev is also nil, all values in the list are the same

  if trc==nil {
     if prev==nil {
        // All values in the list are the same
     } else {
        prev.Next=nil
        current=nil
     }
  } else if trc==current {
    // Not a duplicate entry
    prev=current
    current=current.Next
  } else {
    if prev!=nil {
       prev.Next=trc.Next
    } else {
       // you need to set head =  trc.Next
    }
    current=trc.Next
  }
}

At first glance it looks trivial but after looking deeply into it, issue is actually really annoying. You have to take three cases into account. Elements can be repeating in front. Unless you find single element you have to search for head. Other two cases can be solved by one algorithm, as setting next to nil of node does not matter.

package main

import "fmt"

type LL struct {
	Val  int
	Next *LL
}

func removeDuplicates(h *LL) (res *LL) {
	current := h
	var prev *LL

	// annoying
	if current.Next == nil {
		return current
	}

	// even more annoying
	if current.Next.Val != current.Val {
		res = current
	}

	for current.Next != nil {
		if current.Next.Val == current.Val {
			current.Next = current.Next.Next
			// trailing case - most annoying of them all
			if prev != nil && (current.Next == nil || current.Next.Val != current.Val) {
				prev.Next = current.Next
			}
		} else {
			prev = current
			current = current.Next
			// front repetition - decently annoying
			if res == nil && (current.Next == nil || current.Next.Val != current.Val) {
				res = current
			}
		}
	}

	return
}

func main() {
	l := &LL{1, &LL{1, &LL{2, &LL{2, &LL{3, &LL{4, &LL{4, &LL{5, &LL{6, &LL{6, nil}}}}}}}}}}
	l = removeDuplicates(l)

	current := l
	for current != nil {
		fmt.Print(current.Val)
		current = current.Next
	}

	fmt.Println(l)
}