Golang刷题日志--链表部分（更新中）

1.给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

1 1 2 3 3 --> 1 2 3

判断如果当前节点val与后继节点val相等，则将后继节点的next赋给当前节点next，若不然，则移动当前节点置下一节点（cur=cur.next）

package main

import (
    "fmt"
)

// 删除有序链表重复节点
type ListNode struct {
    Val  int
    Next *ListNode
}

func DeleteDuplicates(head *ListNode) *ListNode {
    //var cur *ListNode
    cur := head
    if cur == nil {
        return cur
    }
    for cur.Next != nil {
        if cur.Val == cur.Next.Val {
            cur.Next = cur.Next.Next
        } else {
            cur = cur.Next
        }
    }
    for head != nil {
        fmt.Print(head.Val, " ")
        head = head.Next
    }
    return head
}

测试代码：

package main

func main() {
    node1 := new(ListNode)
    node2 := new(ListNode)
    node3 := new(ListNode)
    node4 := new(ListNode)
    node5 := new(ListNode)
    node1.Val = 1
    node2.Val = 1
    node3.Val = 2
    node4.Val = 3
    node5.Val = 3
    node1.Next = node2
    node2.Next = node3
    node3.Next = node4
    node4.Next = node5
    node5.Next = nil
    DeleteDuplicates(node1)

}

2.输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

首先获取链表的长度len,其次遍历链表，当索引（cur_index）== len - k + 1，认为找到该位置，将该位置视为新的头节点，返回即可

func GetLastNode(head *ListNode, k int) *ListNode {
    if head == nil {
        return nil
    }
    var len = GetLengthOfList(head)
    if len < k {
        return nil
    }
    var newHead *ListNode
    var cur = head
    var count int
    for cur != nil {
        count++
        if count == len-k+1 {
            newHead = cur
        }
        cur = cur.Next
    }
    for newHead != nil {
        fmt.Print(newHead.Val, " ")
        newHead = newHead.Next
    }
    return newHead
}
func GetLengthOfList(head *ListNode) int {
    var count int
    if head == nil {
        return 0
    }
    for head != nil {
        count++
        head = head.Next
    }
    return count
}

测试代码(同上)

 

 

 3.给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

package main

import "fmt"

//给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
// 1 2 3 4 5--> 1 2 4
// 1 2 --> 2

func removeNthFormEnd(head *ListNode, k int) *ListNode {
    if head == nil {
        return head
    }
    cur := head
    next := head.Next
    length := GetListLength(head)
    if length-k == 0 {
        return cur.Next
    }
    var index int
    for cur != nil {
        index++
        if length-k == index {
            cur.Next = next.Next
        } else {
            cur = cur.Next
            next = next.Next
        }

    }
    for head != nil {
        fmt.Print(head.Val, " ")
        head = head.Next
    }
    return head

}
func GetListLength(head *ListNode) int {
    if head == nil {
        return 0
    }
    var count int
    for head != nil {
        count++
        head = head.Next
    }
    return count
}