package link

import (

    "fmt"

)

type CatNode struct {

    ID   int

    Name string

    next *CatNode

}

func InserCatNode(head *CatNode, newCatNode *CatNode) {

    //初始化链表

    //头结点一开始是空的，当插入第一条数据时，进行初始化

    if head.next == nil {

        head.ID = newCatNode.ID

        head.Name = newCatNode.Name

        head.next = head

        return

    }

    //定义一个临时变量，找到环形的末尾，方便以后进行插入

    tmp := head

    for {

        if tmp.next == head {

            tmp.next = newCatNode

            newCatNode.next = head

            break

        } else {

            tmp = tmp.next

        }

    }

}

func DeleteCatNode(head *CatNode, id int) *CatNode {

    //建立一个节点指向头结点

    tmp := head

    //如果头结点.next为空，说明是空链表

    if tmp.next == nil {

        fmt.Println("空链表")

        return head

    }

    //如果头结点.next就是它自己，说明只有一个元素

    if tmp.next == head {

        //判断该元素是否是要删除的，如果是，则将头结点置为空

        if tmp.ID == id {

            head.next = nil

            return head

        } else {

            fmt.Println("要删除的id不存在")

        }

    }

    //奖励一个辅助指针指向头结点

    helper := head

    //如果头结点正好是我们要删除的

    if tmp.ID == id {

        fmt.Println("进入1")

        //如果头结点.next不是指向它自己，说明除了头结点之外还存在其它节点

        if tmp.next != head {

            fmt.Println("进入2")

            //此时若想删除头结点，我们必须获得一个新的头结点

            tmp = head.next

            //将helper遍历到头结点的前一位

            for {

                if helper.next != head {

                    helper = helper.next

                } else {

                    //同时删除掉原来的头结点

                    fmt.Println("进入3")

                    helper.next = head.next

                    return tmp

                }

            }

        } else {

            //说明只有一个头结点，且是我们要删除的，直接将其置为空

            tmp.next = nil

        }

        //如果头结点不是我们要删除的

    } else {

        for {

            //如果找到一个节点是我们要删除的

            if tmp.next.ID == id {

                //删除该节点

                tmp2 := tmp.next

                tmp.next = tmp2.next

                break

                //如果找不到则继续遍历下一个节点

            } else {

                tmp = tmp.next

                //如果下一个节点是头结点，则表明完成遍历，找不到要删除的节点，并退出

                if tmp.next == head {

                    fmt.Println("未找到该条记录")

                    break

                }

            }

        }

    }

    return head

}

func ListCatNode(head *CatNode) {

    tmp := head

    if tmp.next == nil {

        fmt.Println("空环形链表")

        return

    }

    for {

        fmt.Printf("猫的信息为：id=%d,name=%s\n", tmp.ID, tmp.Name)

        if tmp.next == head {

            break

        } else {

            tmp = tmp.next

        }

    }

}

package main

import (

    "fmt"

    "go_code/data_structure/link"

)

func main() {

    head := &link.CatNode{}

    cat1 := &link.CatNode{

        ID:   ,

        Name: "tom",

    }

    cat2 := &link.CatNode{

        ID:   ,

        Name: "jack",

    }

    cat3 := &link.CatNode{

        ID:   ,

        Name: "bob",

    }

    cat4 := &link.CatNode{

        ID:   ,

        Name: "mike",

    }

    link.InserCatNode(head, cat1)

    link.InserCatNode(head, cat2)

    link.InserCatNode(head, cat3)

    link.InserCatNode(head, cat4)

    link.ListCatNode(head)

    fmt.Println("------------------------------")

    fmt.Println("删除id=1后的结果是：")

    h1 := link.DeleteCatNode(head, )

    link.ListCatNode(h1)

    fmt.Println("------------------------------")

    fmt.Println("删除id=4后的结果是：")

    h2 := link.DeleteCatNode(h1, )

    link.ListCatNode(h2)

    fmt.Println("------------------------------")

    fmt.Println("删除id=3后的结果是：")

    h3 := link.DeleteCatNode(h2, )

    link.ListCatNode(h3)

    fmt.Println("------------------------------")

    fmt.Println("删除id=2后的结果是：")

    h4 := link.DeleteCatNode(h3, )

    link.ListCatNode(h4)

}