39.Go语言·数据结构·双向链表

main.go

// Go语言·数据结构
package main

import (
    "fmt"
)

var content string = `
————————————————Go语言·数据结构————————————————————
一、链表
    是有序的列表，

二、双向链表

`

// 定义一个节点
type HeroNode struct {
    no       int
    name     string
    nickname string
    prev     *HeroNode //表示指向上一个节点
    next     *HeroNode //表示指向下一个节点
}

// 在双向链表的最后加入。
func PushDoubleLinkNode(headNode *HeroNode,nextNode *HeroNode) {
    // 思路
    // 1.先找到该链表最后的节点。
    // 2.创建一个辅助节点
    temp := headNode
    for {
        // 找到了链表最后的节点
        if temp.next == nil{
            break       
        }
        // 不断的指向下一个节点
        temp = temp.next
    }
    //最后的节点指向下一个节点 
    temp.next = nextNode
    // nextNode的上一个节点就是temp
    nextNode.prev = temp
}

// 在双向链表加入。 有序的
func PushDoubleLinkNodeSort(headNode *HeroNode,nextNode *HeroNode) {
    // 思路
    // 1.先找到该链表适当的节点。
    // 2.创建一个辅助节点
    var flag = true
    temp := headNode
    for {
        // 找到了链表最后的节点
        if temp.next == nil{
            break       
        }else if temp.next.no>nextNode.no{
            // 说明nextNode接口，就应该直接插入到temp后面
            break
        }else if temp.next.no==nextNode.no{
            // 链表中已经存在咯，就不允许插入
            flag = false
            break
        }
        // 不断的指向下一个节点
        temp = temp.next
    }
    if !flag {
        fmt.Println("链表中已经存在咯，就不允许插入!")
    }else{
        nextNode.next = temp.next
        nextNode.prev = temp
        if temp.next != nil{
            temp.next.prev = nextNode   
        }
        temp.next     = nextNode
    }
}


// 打印链表 顺序
func ListDoubleLinkNodeAsc(head *HeroNode) {
    // 1.先找到该链表最后的节点。
    // 2.创建一个辅助节点
    temp := head
    
    if temp.next == nil{
        fmt.Println("链表空空如也~~~")        
    }

    // 遍历链表
    for {
        fmt.Printf("[%d,%s,%s]===>",
            temp.next.no,temp.next.name,temp.next.nickname)
        // 不断的指向下一个节点
        temp = temp.next
        // 最后一个节点咯。
        if temp.next == nil{
            break   
        }
    }
}

// 打印链表 逆序
func ListDoubleLinkNodeDesc(head *HeroNode) {
    // 1.先找到该链表最后的节点。
    // 2.创建一个辅助节点
    temp := head
    
    if temp.next == nil{
        fmt.Println("链表空空如也~~~")
        return      
    }

    for {
        // 找到了链表最后的节点
        if temp.next == nil{
            break       
        }
        // 不断的指向下一个节点
        temp = temp.next
    }

    // 遍历链表
    for {
        fmt.Printf("[%d,%s,%s]===>",temp.no,temp.name,temp.nickname)
        // 不断的指向下一个节点
        temp = temp.prev
        // 最后一个节点咯。
        if temp.prev == nil{
            break   
        }
    }
}

// 删除一个
func PopDoubleLinkNode(head *HeroNode,id int) {
    var flag = false
    temp := head
    for {
        // 找到了链表最后的节点
        if temp.next == nil{
            break       
        }else if temp.next.no==id{
            flag = true
            break
        }
        // 不断的指向下一个节点
        temp = temp.next
    }
    if flag {
        temp.next = temp.next.next
        if temp.next != nil {
            temp.next.prev = temp 
        }
    }else{
        fmt.Println("删除的节点不存在~~")
    }
}


func main() {
    // 1.先创建头节点,空的，默认值
    head := &HeroNode{}

    // 创建一个新的节点
    next := &HeroNode{
        no:1,
        name:"宋江",
        nickname :"及时雨",
    }

    PushDoubleLinkNodeSort(head, next)

    next2 := &HeroNode{
        no:4,
        name:"林冲",
        nickname :"豹子头",
    }
    PushDoubleLinkNodeSort(head, next2)

    next3 := &HeroNode{
        no:2,
        name:"卢俊义",
        nickname :"玉麒麟",
    }
    PushDoubleLinkNodeSort(head, next3)

    next4 := &HeroNode{
        no:3,
        name:"吴用",
        nickname :"智多星",
    }
    PushDoubleLinkNodeSort(head, next4)

    ListDoubleLinkNodeAsc(head)

    fmt.Println()

    PopDoubleLinkNode(head, 2)

    ListDoubleLinkNodeDesc(head)

    fmt.Println()
}