Remove Friends Hackerearth problem

package main

import "fmt"

type linkedList struct {
    data       int
    next, prev *linkedList
}

func addNode(data int, root *linkedList) *linkedList {
    if (*root).next == nil && (*root).prev == nil {
        (*root).data = data
        (*root).next = new(linkedList)
        return root
    }
    pointer := root
    for (*pointer).next.next != nil {
        pointer = (*pointer).next
    }
    (*pointer).next.data = data
    (*pointer).next.prev = pointer
    (*pointer).next.next = new(linkedList)
    return pointer
}

func drop(pointer *linkedList) {
    (*pointer).prev.next = (*pointer).next
    (*pointer).next.prev = (*pointer).prev
}

func traverse(pointer *linkedList) {
    for (*pointer).next != nil {
        //fmt.Println("debug ->", *pointer)
        fmt.Printf("%d ", (*pointer).data)
        pointer = (*pointer).next
    }
}

func main() {
    var tmpData int
    var N, K, testcases int

    fmt.Scanf("%d", &testcases)

    for testcases != 0 {
        fmt.Scanf("%d %d", &N, &K)

        root := new(linkedList)
        var nextInsert *linkedList

        for i := 0; i < N; i++ {
            fmt.Scanf("%d", &tmpData)
            if nextInsert == nil {
                nextInsert = addNode(tmpData, root)
            } else {
                nextInsert = addNode(tmpData, nextInsert)
            }
        }

        var g *linkedList
        pointer := root

        for K != 0 && (*pointer).next.next != nil {

            if (*pointer).data < (*pointer).next.data {
                tmp := pointer
                if root == tmp {
                    root = (*root).next
                    pointer = root
                    (*root).prev = nil
                    (*tmp).next = nil
                    K--
                    continue
                }
                drop(tmp)
                K--
            } else {
                if g != nil {
                    if (*g).data < (*pointer).data {
                        tmp := g
                        g = nil
                        if root == tmp {
                            root = (*root).next
                            pointer = root
                            (*root).prev = nil
                            (*tmp).next = nil
                            K--
                            continue
                        }
                        drop(tmp)
                        K--
                    }

                } else {
                    g = pointer
                }
            }
            pointer = (*pointer).next
        }
        for K != 0 {
            tmp := pointer
            pointer = (*pointer).prev
            drop(tmp)
            K--
        }
        traverse(root)
        fmt.Print("\n")
        testcases--
    }
}