书旅
书旅

数据结构与算法系列之链表操作全集（一）（GO）

前言

这里不介绍链表是什么之类的概念，大家可以找一找相关的书籍或文章看看，本文主要是用GO来实现一些链表的操作

说明：刚开始学习GO，可能用到的实现方法不是最简便的，意思表达出来了就可以，大家凑合着看【手动狗头】。如有错误，欢迎指正

以下的代码均可从这里获取

https://github.com/Rain-Life/learnGo

收获：做链表的题，一定！一定！一定！要画图！要画图！要画图！不然，特别容易乱，很难一遍写出0 error,0 warning的链表代码

链表

数据结构与算法系列之链表操作全集（一）（GO）_第1张图片

单链表的基本操作

链表通过指针将一组零散的内存块串联在一起，这里的内存块称为链表的结点。为了将这些节点给串起来，每个链表的结点除了存储数据之外，还会记录下一个结点的指针（即下一个结点的地址），这个指针称为：后继指针
数据结构与算法系列之链表操作全集（一）（GO）_第2张图片

定义单链表基本结构
定义链表结构
//定义结点中数据的类型为接口类型，可收任意类型数据
type Object interface {}

//定义结点的结构体
type Node struct {
    Data Object
    Next *Node
}

//定义链表的结构体
type List struct {
    headNode *Node
}
判断链表是否为空
func (list *List) IsEmpty() bool  {
    if list.headNode == nil {
        return true
    }

    return false
}
获取链表的长度
func (list *List) Length() int {
    currentNode := list.headNode
    count := 0
    for currentNode != nil {
        count++
        currentNode = currentNode.Next
    }

    return count
}
添加结点
向链表头部添加结点
func (list *List) AddFromHead(data Object) *Node {
    node := &Node{Data:data}
    if list.IsEmpty() {
        list.headNode = node
        return node
    }
    node.Next = list.headNode
    list.headNode = node

    return node
}
向链表尾部添加结点
func (list *List) Append(data Object) {
    node := &Node{Data: data}
    if list.IsEmpty() {
        list.headNode = node
    } else {
        currentNode := list.headNode
        for currentNode.Next != nil {
            currentNode = currentNode.Next
        }

        currentNode.Next = node
    }
}
向链表中指定位置添加结点
func (list *List) Insert(position int, data Object) {
    if position <= 1 {
        list.AddFromHead(data)
    } else if position > list.Length() {
        list.Append(data)
    } else {
        pre := list.headNode
        count := 1
        for count < (position-1) {
            pre = pre.Next
            count++
        }//循环退出以后pre刚好在position-1的位置
        node := &Node{Data: data}
        node.Next = pre.Next
        pre.Next = node
    }
}
删除结点
删除链表头部结点
func (list *List) RemoveHeadNde() Object {
    if list.IsEmpty() {
        fmt.Println("链表为空")
        return nil
    }

    currentNode := list.headNode
    if list.headNode.Next == nil {
        list.headNode = nil
        return currentNode.Data
    }
    list.headNode = currentNode.Next

    return currentNode.Data
}
删除链表尾部结点
func (list *List) RemoveLastNode() Object {
    if list.IsEmpty() {
        return "链表为空"
    }

    currentNode := list.headNode
    for currentNode.Next.Next != nil {
        currentNode = currentNode.Next
    }

    data := currentNode.Next.Data
    currentNode.Next = nil
    return data
}
删除指定值的结点
func (list *List) Remove(data Object)  {
    pre := list.headNode
    if pre.Data == data{
        list.headNode = pre.Next
    } else {
        for pre.Next != nil {
            if pre.Next.Data == data {
                pre.Next = pre.Next.Next
            } else {
                pre = pre.Next
            }
        }
    }
}
删除指定位置的结点
func (list *List) RemovePosition(position int)  {
    pre := list.headNode
    if position <= 1 {
        list.headNode = nil
    } else if position > list.Length() {
        fmt.Println("超出链表长度")
    } else {
        count :=1
        for count != position-1 && pre.Next != nil {
            count++
            pre = pre.Next
        }

        pre.Next = pre.Next.Next
    }
}
查找结点
链表中是否包含某个值的节点
func (list *List) Contain(data Object) bool {
    currentNode := list.headNode
    for currentNode != nil {
        if currentNode.Data == data {
            return true
        }
        currentNode = currentNode.Next
    }

    return false
}
遍历链表
遍历
func (list *List) Traverse()  {
    if list.IsEmpty() {
        fmt.Println("链表为空")
    }
    currentNode := list.headNode
    for currentNode != nil {
        fmt.Printf("%v\t", currentNode.Data)
        currentNode = currentNode.Next
    }
}
测试
package main

import (
    "fmt"
    "learnGo/linkedList/node"
)

func print(list node.List)  {
    fmt.Printf("链表长度%d\n", list.Length())
    fmt.Println("遍历链表所有结点：")
    list.Traverse()
    fmt.Println()
    fmt.Println()
}

func main() {
    list := node.List{}

    //向链表的尾部追加元素
    fmt.Println("++++++++1、向链表尾部追加结点++++++++")
    list.Append(3)
    list.Append(8)
    list.Append(1)
    list.Append(9)

    list.Append("PHP")
    list.Append("Golang")
    list.Append("Java")
    list.Append("JavaScript")
    print(list)

    fmt.Println("++++++++2、判断链表是否为空++++++++")
    fmt.Printf("链表是否为空：%v", list.IsEmpty())
    fmt.Println()
    fmt.Println()
    
    //向链表的头部添加元素
    fmt.Println("++++++++3、向链表的头部添加一个结点++++++++")
    fmt.Println()
    list.AddFromHead("firstNode")
    print(list)
    
    fmt.Println("++++++++4、向链表尾部添加结点++++++++")
    fmt.Println()
    list.Append("lastNode")
    print(list)
    
    fmt.Println("++++++++5、向链表尾部添加结点++++++++")
    fmt.Println()
    list.Insert(3, "thirdNode")
    print(list)
    
    fmt.Println("++++++++6、删除链表头结点++++++++")
    fmt.Println()
    list.RemoveHeadNde()
    print(list)
    
    fmt.Println("++++++++7、删除链表尾结点++++++++")
    fmt.Println()
    list.RemoveLastNode()
    print(list)

    fmt.Println("++++++++8、删除链表中指定值的结点++++++++")
    fmt.Println()
    list.Remove(9)
    print(list)

    fmt.Println("++++++++9、删除链表中指定位置的结点++++++++")
    fmt.Println()
    list.RemovePosition(3)
    print(list)
    
    fmt.Println("++++++++10、查询链表中是否包含某一个结点++++++++")
    fmt.Println()
    res := list.Contain("Golang")
    fmt.Printf("是否存在Golang结点：%v\n", res)
    print(list)
}

实现各种类型的链表

各种链表简介
循环链表

循环链表是一种特殊的单链表。循环跟单链表唯一的区别就在尾结点。单链表的尾结点指针指向空地址，表示这就是最后的结点了。而循环链表的尾结点指针是指向链表的头结点
数据结构与算法系列之链表操作全集（一）（GO）_第3张图片

循环链表的优点就是，从链尾到链头比较方便。当要处理的数据具有环型结构特点时，就特别适合采用循环链表

双向链表

和单向链表相比，双向链表有两个指针，指向前一个结点的指针是前驱指针（prev），指向后一个结点的是后继指针（next）

有了前驱指针，可以更加方便的获取当前结点的前一个结点。按照单链表的方式，我们如果要获取前驱结点，要么遍历的时候用一个变量来保存前驱结点，要么再次遍历获取前驱结点。而双向链表可以在O(1)复杂度下找到前驱结点

单向链表和双向链表对比

  • 如果存储同样多的数据，双向链表要比单链表占用更多的内存空间。虽然两个指针比较浪费存储空间，但可以支持双向遍历，这样也带来了双向链表操作的灵活性
  • 双向链表的插入和删除操作更高效，因为可以很容易获取到前驱结点
  • 如果有一个有序的链表，双向链表的按值查询的效率也要比单链表高一些。因为，我们可以记录上次查找的位置 p，每次查询时，根据要查找的值与 p 的大小关系，决定是往前还是往后查找，所以平均只需要查找一半的数据

双向链表尽管比较费内存，但还是比单链表的应用更加广泛的原因是空间换时间的思想

当内存空间充足的时候，如果我们更加追求代码的执行速度，我们就可以选择空间复杂度相对较高、但时间复杂度相对很低的算法或者数据结构。相反，如果内存比较紧缺，比如代码跑在手机或者单片机上，这个时候，就要反过来用时间换空间的设计思路

来源：数据结构与算法之美

双向循环链表

将循环链表和双向链表结合，得到的就是：双向循环链表
数据结构与算法系列之链表操作全集（一）（GO）_第4张图片

各种类型的链表操作

这部分直接上代码了

循环链表

这里直接放完整的各种操作的代码，重点地方会加上说明

loopLinkedList.go

package loopLinkList

import "fmt"

//循环链表
type Object interface {}

type Node struct {
    Data Object
    Next *Node
}

type List struct {
    headNode *Node
}

//判断循环链表是否为空（与单链表的实现没有区别）
func (list *List) IsEmpty() bool {
    if list.headNode == nil {
        return true
    }

    return false
}

//获取循环链表的长度（与单链表的获取长度区别在于循环的终止条件）
func (list *List) Length() int {
    if list.headNode == nil {
        return 0
    }

    currentNode := list.headNode
    count := 1
    for currentNode.Next != list.headNode {
        count++
        currentNode = currentNode.Next
    }

    return count
}

//向循环链头部添加结点
func (list *List) AddFromHead(data Object) {
    node := &Node{Data: data}
    //链表为空的情况
    if list.IsEmpty() {
        list.headNode = node
        list.headNode.Next = list.headNode //单链表没有这一步
    } else {
        currentNode := list.headNode
        for currentNode.Next != list.headNode { //需要先找到最后一个结点
            currentNode = currentNode.Next
        }

        node.Next = list.headNode
        currentNode.Next = node //单链表没有这一步操作，将最后一个节点的next指向头结点
        list.headNode = node
    }
}


//向循环链表的尾部添加结点
func (list *List) Append(data Object) {
    node := &Node{Data: data}

    if list.IsEmpty() {
        list.headNode = node
        list.headNode.Next = node
    } else {
        currentNode := list.headNode
        for currentNode.Next != list.headNode {
            currentNode = currentNode.Next
        }

        currentNode.Next = node
        node.Next = list.headNode //单链表没有这一步操作（让最后一个节点指向头结点）
    }
}

//向循环链表的指定位置添加结点（跟单链表是一样的）
func (list *List) Insert(position int, data Object) {
    if position <= 1 {
        list.AddFromHead(data)
    } else if position > list.Length() {
        list.Append(data)
    } else {
        currentNode := list.headNode
        count := 1
        for count < position-1 {
            currentNode = currentNode.Next
            count++
        }

        node := &Node{Data: data}
        node.Next = currentNode.Next
        currentNode.Next = node
    }
}

//删除循环链表的头结点
func (list *List) RemoveHeadNde() {
    if list.IsEmpty() {
        fmt.Println("链表是空的")
        return
    }

    currentNode := list.headNode
    lastNode := list.headNode
    //考虑循环链表只有一个结点的情况
    if currentNode.Next == list.headNode {
        list.headNode = nil
        return
    }

    for lastNode.Next != list.headNode {
        lastNode = lastNode.Next
    }

    list.headNode = currentNode.Next
    lastNode.Next = list.headNode
}

//删除循环链表的尾结点
func (list *List) RemoveLastNode() {
    if list.IsEmpty() {
        fmt.Println("链表是空的")
        return
    }

    currentNode := list.headNode
    //考虑循环链表只有一个结点的情况
    if currentNode.Next == list.headNode {
        list.headNode = nil
        return
    }

    for currentNode.Next.Next != list.headNode {
        currentNode = currentNode.Next
    }

    currentNode.Next = list.headNode
}

//删除循环链表中指定位置的节点 (需考虑删除的结点是不是第一个或最后一个)
func (list *List) RemovePosition(position int) {
    if list.IsEmpty() {
        fmt.Println("链表为空")
        return
    }

    if position <= 1 {
        list.RemoveHeadNde()
    } else if position > list.Length() {
        list.RemoveLastNode()
    } else {
        currentNode := list.headNode
        count := 1
        if count != position-1 && currentNode.Next != list.headNode{
            count++
            currentNode = currentNode.Next
        }

        currentNode.Next = currentNode.Next.Next
    }
}

//删除循环链表中指定值的结点
func (list *List) Remove(data Object) {
    if list.IsEmpty() {
        fmt.Println("链表为空")
        return
    }

    currentNode := list.headNode

    //删除的结点为头结点时
    if currentNode.Data == data {
        list.RemoveHeadNde()
        return
    }

    for currentNode.Next != list.headNode {
        if currentNode.Next.Data == data {
            currentNode.Next = currentNode.Next.Next
            return
        } else {
            currentNode = currentNode.Next
        }
    }

    if currentNode.Next == list.headNode {
        list.RemoveLastNode()
    }
}

//查找循环链表中指定结点
func (list *List) Contain(data Object) bool {
    if list.IsEmpty() {
        return false
    }

    currentNode := list.headNode
    for currentNode.Next != list.headNode {
        if currentNode.Data == data {
            return true
        }

        currentNode = currentNode.Next
    }

    if currentNode.Data == data {
        return true
    }

    return false
}

//遍历循环链表
func (list *List) Traverse() {
    if list.IsEmpty() {
        fmt.Println("循环链表为空")
        return
    }

    currentNode := list.headNode
    if currentNode.Next == list.headNode { //兼容循环链表只有一个结点的情况
        fmt.Printf("%v\t", currentNode.Data)
        return
    }

    for currentNode.Next != list.headNode {
        fmt.Printf("%v\t", currentNode.Data)
        currentNode = currentNode.Next
    }
    fmt.Printf("%v\t", currentNode.Data)
}

entry.go（测试）

package main

import (
    "fmt"
    "learnGo/linkedList/loopLinkList"
)

func print(list loopLinkList.List)  {
    fmt.Printf("链表长度：%d\n", list.Length())
    fmt.Println("遍历链表所有结点：")
    list.Traverse()
    fmt.Println()
    fmt.Println()
}

func main() {
    list := loopLinkList.List{}

    fmt.Println("++++++++1、判断链表是否为空++++++++")
    fmt.Printf("链表是否为空：%v\n", list.IsEmpty())
    print(list)
    
    fmt.Println("++++++++2、获取链表长度++++++++")
    fmt.Printf("获取链表长度：%d\n", list.Length())
    print(list)
    
    fmt.Println("++++++++3、向循环链头部添加结点++++++++")
    list.AddFromHead("firstNode")
    print(list)

    fmt.Println("++++++++4、向循环链尾部添加结点++++++++")
    list.Append("lastNode")
    print(list)

    fmt.Println("++++++++5、向循环链指定位置添加结点++++++++")
    list.Insert(1,"secondNode")
    print(list)

    fmt.Println("++++++++6、删除循环链的头结点++++++++")
    list.RemoveHeadNde()
    print(list)
    
    fmt.Println("++++++++7、删除循环链的尾结点++++++++")
    list.RemoveLastNode()
    print(list)

    fmt.Println("++++++++8、查找循环链表中指定结点++++++++")
    fmt.Printf("是否包含secondNode节点：%v\n", list.Contain("secondNode"))
    print(list)

    fmt.Println("++++++++9、删除循环链表中指定位置的结点++++++++")
    list.RemovePosition(1)
    print(list)

    fmt.Println("++++++++10、删除循环链表中指定值的结点++++++++")
    list.Remove("lastNode")
    print(list)

}
双向链表

doublyLinkedList.go

package doublyLinkedList

import (
    "fmt"
)

//双向链表
type Object interface {}

type Node struct {
    Data Object
    Prev,Next *Node
}

type List struct {
    headNode *Node
}

//说明
/**
1、如果结点的Next指向为null，则说明是最后一个结点
2、第一个结点的prev指向为空
3、双向链表和单向链表差不多，区别就是删除和添加结点的时候更方便了，因为很方便的可以获取到前一个结点
*/

//判断双向链表是否为空
func (list *List) IsEmpty() bool {
    if list.headNode == nil {
        return true
    }

    return false
}

//遍历双向链表（跟遍历单链表一模一样）
func (list *List) Traverse() {
    if list.IsEmpty() {
        fmt.Println("双线链表为空")
        return
    }

    currentNode := list.headNode
    for currentNode != nil {
        fmt.Printf("%v\t", currentNode.Data)
        currentNode = currentNode.Next
    }
}

//获取双向链表的长度（跟获取单链表长度一模一样）
func (list *List) Length() int {
    if list.IsEmpty() {
        return 0
    }

    count := 0
    currentNode := list.headNode
    for currentNode != nil {
        count++
        currentNode = currentNode.Next
    }

    return count
}

//从双向链表头部开始增加结点
func (list *List) AddFromHead(data Object) *Node {
    node := &Node{Data: data}
    if list.IsEmpty() {
        list.headNode = node
        return node
    }

    list.headNode.Prev = node
    node.Next = list.headNode
    list.headNode = node

    return node
}

//从双向链表尾部添加结点
func (list *List) Append(data Object) {
    node := &Node{Data: data}
    if list.IsEmpty() {
        list.headNode = node
    } else {
        currentNode := list.headNode
        for currentNode.Next != nil {
            currentNode = currentNode.Next
        }

        currentNode.Next = node
        node.Prev = currentNode
    }
}

/**
 * 向双向链表的指定位置插入结点
 *
 * 说明：在单向链表中，我是通过找到我要插入的这个结点的前一个结点，然后将要插入的结点，
 * 插入到这个结点的后边（因为插入结点需要找到当前结点的前一个结点，为了避免再次遍历找前一个结点，所以采用了这种方式）
 * 而双向链表就不需要这么做了，找到指定位置的结点，新的插入到它前边就可以了
 */
func (list *List) Insert(position int, data Object) {
    if position <= 1 {
        list.AddFromHead(data)
    } else if position > list.Length() {
        list.Append(data)
    } else {
        currentNode := list.headNode
        count := 1
        for count != position {
            currentNode = currentNode.Next
            count++
        }
        //找到了指定位置的结点，然后将要插入的结点，插到这个节点前边即可(注意顺序，画图最容易理解)
        node := &Node{Data: data}
        node.Next = currentNode
        node.Prev = currentNode.Prev
        currentNode.Prev.Next = node
        currentNode.Prev = node
    }
}

//删除链表头结点
func (list *List) RemoveHeadNde() Object {
    if list.IsEmpty() {
        fmt.Println("链表为空")
        return nil
    }

    currentNode := list.headNode
    if currentNode.Next == nil && currentNode.Prev == nil {
        list.headNode = nil
        return currentNode.Data
    }

    list.headNode = currentNode.Next
    currentNode.Prev = nil

    return currentNode.Data
}

//删除链表尾结点
func (list *List) RemoveLastNode() Object {
    if list.IsEmpty() {
        fmt.Println("链表为空")
        return nil
    }

    if list.headNode.Next == nil {
        list.headNode = nil
    }
    
    currentNode := list.headNode
    for currentNode.Next != nil {
        currentNode = currentNode.Next
    }
    currentNode.Prev.Next = nil

    return currentNode.Prev.Data
}

//删除双向表中指定值的结点
func (list *List) Remove(data Object)  {
    if list.IsEmpty() {
        fmt.Println("链表为空")
        return
    }

    currentNode := list.headNode
    if list.headNode.Next == nil && list.headNode.Data == data {
        list.headNode = nil
    }

    fmt.Println(data, currentNode.Data, currentNode.Data == data)
    for currentNode != nil {
        if currentNode.Data == data && currentNode == list.headNode {
            list.headNode = currentNode.Next
        } else if currentNode.Data == data && currentNode.Prev != nil {
            currentNode.Prev.Next = currentNode.Next
            currentNode.Next.Prev = currentNode.Prev
        } else {
            currentNode = currentNode.Next
        }
    }
}

//删除双向链表中指定位置的结点
func (list *List) RemovePosition(position int) {
    if list.IsEmpty() {
        fmt.Println("链表为空")
        return
    }

    if position <=1 {
        list.RemoveHeadNde()
    } else if position > list.Length() {
        list.RemoveLastNode()
    } else {
        currentNode := list.headNode
        count := 1
        for count != position {
            count++
            currentNode = currentNode.Next
        }
        currentNode.Prev.Next = currentNode.Next
        currentNode.Next.Prev = currentNode.Prev
    }
}

//查询双向链表中是否包含某一个结点(和单向链表一样)
func (list *List) Contain(data Object) bool {
    if list.IsEmpty() {
        fmt.Println("链表为空")
        return false
    }

    currentNode := list.headNode
    for currentNode != nil {
        if currentNode.Data == data {
            return true
        }

        currentNode = currentNode.Next
    }

    return false
}

entry.go（测试）

package main

import (
    "fmt"
    "learnGo/linkedList/doublyLinkedList"
)

func print(list doublyLinkedList.List)  {
    fmt.Printf("链表长度%d\n", list.Length())
    fmt.Println("遍历链表所有结点：")
    list.Traverse()
    fmt.Println()
    fmt.Println()
}

func main() {
    list := doublyLinkedList.List{}

    fmt.Println("++++++++1、判断链表是否为空++++++++")
    fmt.Printf("链表是否为空：%v", list.IsEmpty())
    fmt.Println()
    fmt.Println()

    fmt.Println("++++++++2、向双向链表头部添加元素++++++++")
    fmt.Println()
    list.AddFromHead(1)
    list.AddFromHead(2)
    list.AddFromHead(3)
    print(list)

    fmt.Println("++++++++3、向双向链表尾部添加元素++++++++")
    fmt.Println()
    list.Append("Golang")
    list.Append("PHP")
    list.Append("Java")
    print(list)

    fmt.Println("++++++++4、向双向链表的指定位置插入结点++++++++")
    fmt.Println("++++++++(1)向双向链表的【第一个】位置插入结点++++++++")
    list.Insert(1, "First")
    print(list)

    fmt.Println("++++++++(2)向双向链表的【第三个】位置插入结点++++++++")
    list.Insert(3, "Third")
    print(list)

    fmt.Println("++++++++(3)向双向链表的【最后】位置插入结点++++++++")
    list.Insert(list.Length()+1, "Last")
    print(list)

    fmt.Println("++++++++5、删除双向链表的头结点++++++++")
    fmt.Println()
    list.RemoveHeadNde()
    print(list)

    fmt.Println("++++++++6、删除双向链表的尾结点++++++++")
    fmt.Println()
    list.RemoveLastNode()
    print(list)

    fmt.Println("++++++++7、删除双向表中指定值的结点++++++++")
    list.Remove(3)//这里的类型要和你插入时的类型一致（弱类型语言写习惯了，很容易忘了）
    print(list)

    fmt.Println("++++++++8、删除双向表中指定位置的结点++++++++")
    fmt.Println("++++++++(1)删除双向链表的【第一个】位置结点++++++++")
    list.RemovePosition(1)
    print(list)

    fmt.Println("++++++++(2)删除双向链表的【第三个】位置结点++++++++")
    list.RemovePosition(3)
    print(list)

    fmt.Println("++++++++(3)删除双向链表的【最后】位置结点++++++++")
    list.RemovePosition(list.Length())
    print(list)

    fmt.Println("++++++++9、查询双向链表中是否包含某一个结点++++++++")
    fmt.Println()
    fmt.Printf("是否存在Golang结点：%v\n", list.Contain(2))
}
双向循环链表

doublyLoopLinkedList.go

package doublyLoopLinkedList

import (
    "fmt"
)

type Object interface {}

type Node struct {
    Data Object
    Prev,Next *Node
}

type List struct {
    headNode *Node
}

//判断双向循环链表是否为空
func (list *List) IsEmpty() bool {
    if list.headNode == nil {
        return true
    }

    return false
}

//遍历双向循环链表
func (list *List) Traverse() {
    if list.IsEmpty() {
        fmt.Println("链表为空")
        return
    }

    if list.headNode.Next == nil {//兼容双向循环链表只有一个结点的情况
        fmt.Printf("%v\t", list.headNode.Data)
        return
    }

    currentNode := list.headNode
    for currentNode.Next != list.headNode {
        fmt.Printf("%v\t", currentNode.Data)
        currentNode = currentNode.Next
    }
    fmt.Printf("%v\t", currentNode.Data)
}

//获取双向循环链表的长度
func (list *List) Length() int {
    if list.IsEmpty() {
        return 0
    }

    count := 1
    currentNode := list.headNode
    for currentNode.Next != list.headNode {
        count++
        currentNode = currentNode.Next
    }

    return count
}

//从双向循环链表头部添加结点(一定一定要画图，比较好理解)
func (list *List) AddFromHead(data Object) *Node {
    node := &Node{Data: data}
    if list.IsEmpty() {
        list.headNode = node
        return node
    }

    currentNode := list.headNode

    if currentNode.Next == nil { //考虑只有一个节点的时候
        node.Prev = currentNode
        currentNode.Next = node
        node.Next = currentNode
        currentNode.Prev = node
        list.headNode = node
        return node
    }

    node.Prev = currentNode.Prev
    currentNode.Prev.Next = node
    currentNode.Prev = node
    node.Next = currentNode

    list.headNode = node

    return node
}

//从双向循环链表尾部添加结点
func (list *List) Append(data Object) *Node {
    node := &Node{Data: data}
    if list.IsEmpty() {
        list.headNode = node
        return node
    }

    currentNode := list.headNode
    currentNode.Prev.Next = node
    node.Prev = currentNode.Prev
    currentNode.Prev = node
    node.Next = currentNode

    return node
}

//向双向循环链表的指定位置插入结点
func (list *List) Insert(position int, data Object) {
    if position <=1 {
        list.AddFromHead(data)
    } else if position > list.Length() {
        list.Append(data)
    } else {
        node := &Node{Data: data}
        currentNode := list.headNode
        count := 1
        for count != position {
            count++
            currentNode = currentNode.Next
        }

        //将待插入的节点插入到当前节点的前边即可(这块的逻辑其实和双向链表的在中间位子插入结点逻辑一样)
        currentNode.Prev.Next = node
        node.Prev = currentNode.Prev
        currentNode.Prev = node
        node.Next = currentNode
    }
}

//删除双向循环链表头结点
func (list *List) RemoveHeadNde() Object {
    if list.IsEmpty() {
        fmt.Println("双向循环链表为空")
        return ""
    }

    currentNode := list.headNode
    if currentNode.Next == nil {//只有一个结点的情况
        list.headNode = nil
        return currentNode.Data
    }

    currentNode.Prev.Next = currentNode.Next
    currentNode.Next.Prev = currentNode.Prev
    list.headNode = currentNode.Next

    return currentNode.Data
}

//删除双向循环链表尾结点
func (list *List) RemoveLastNode() Object {
    if list.IsEmpty() {
        fmt.Println("双向循环链表为空")
        return ""
    }

    currentNode := list.headNode
    if currentNode.Next == nil {//只有一个结点的情况
        list.headNode = nil
        return list.headNode.Data
    }

    lastNode := list.headNode.Prev
    lastNode.Prev.Next = currentNode
    currentNode.Prev = lastNode.Prev

    return lastNode.Data
}

//删除双向循环链表中指定值的结点
func (list *List) Remove(data Object) bool {
    if list.IsEmpty() {
        fmt.Println("双向循环链表为空")
        return false
    }

    //如果链表只有一个节点
    if list.headNode.Next == nil {
        if list.headNode.Data == data {
            list.headNode = nil
            return true
        }
        return false
    }

    currentNode := list.headNode
    //如果值刚好等于第一个节点的值
    if currentNode.Data == data {
        list.RemoveHeadNde()
        return true
    }

    //如果值刚好等于最后一个结点的值
    for currentNode.Next != list.headNode {
        if currentNode.Data == data {
            //删除中间节点
            currentNode.Prev.Next = currentNode.Next
            currentNode.Next.Prev = currentNode.Prev
            return true
        } else {
            currentNode = currentNode.Next
        }
    }

    if currentNode.Data == data { //刚好是最后一个结点的时候
        list.RemoveLastNode()
        return true
    }

    return false
}

//删除双向循环链表中指定位置的结点
func (list *List) RemovePosition(position int) {

    if list.IsEmpty() {
        fmt.Println("双向循环链表为空")
        return
    }

    if position <= 1 {
        list.RemoveHeadNde()
    } else if position > list.Length() {
        list.RemoveLastNode()
    } else {
        currentNode := list.headNode
        count := 1
        for count != position {
            count++
            currentNode = currentNode.Next
        }

        currentNode.Prev.Next = currentNode.Next
        currentNode.Next.Prev = currentNode.Prev
    }
}

//查询双向循环链表中是否包含某一个结点(跟循环链表的查找逻辑一样)
func (list *List) Contain(data Object) bool {
    if list.IsEmpty() {
        fmt.Println("双向循环链表为空")
        return false
    }

    currentNode := list.headNode
    for currentNode.Next != list.headNode {
        if currentNode.Data == data {
            return true
        }

        currentNode = currentNode.Next
    }

    if currentNode.Data == data {
        return true
    }

    return false
}

entry.go

package main

import (
    "fmt"
    "learnGo/linkedList/doublyLoopLinkedList"
)

func print(list doublyLoopLinkedList.List)  {
    fmt.Printf("链表长度%d\n", list.Length())
    fmt.Println("遍历链表所有结点：")
    list.Traverse()
    fmt.Println()
    fmt.Println()
}

func main() {
    list := doublyLoopLinkedList.List{}

    fmt.Println("++++++++1、判断链表是否为空++++++++")
    fmt.Printf("链表是否为空：%v", list.IsEmpty())
    fmt.Println()
    fmt.Println()

    fmt.Println("++++++++2、向双向循环链表头部添加结点++++++++")
    fmt.Println()
    list.AddFromHead(1)
    list.AddFromHead(2)
    list.AddFromHead(3)
    print(list)

    fmt.Println("++++++++3、向双向循环链表尾部添加结点++++++++")
    fmt.Println()
    list.Append("lastNode")
    print(list)

    fmt.Println("++++++++4、向双向循环链表指定位置添加结点++++++++")
    fmt.Println()
    list.Insert(1,"firstNode")
    print(list)

    fmt.Println("++++++++5、删除双向循环链表头结点++++++++")
    fmt.Println()
    list.RemoveHeadNde()
    print(list)

    fmt.Println("++++++++6、删除双向循环链表尾结点++++++++")
    fmt.Println()
    list.RemoveLastNode()
    print(list)

    fmt.Println("++++++++7、删除双向循环链表中指定值的结点++++++++")
    fmt.Println()
    list.Remove(1)
    print(list)

    fmt.Println("++++++++8、删除双向循环链表中指定位置的结点++++++++")
    fmt.Println()
    list.RemovePosition(list.Length()-1)
    print(list)

    fmt.Println("++++++++9、查询双向循环链表中是否包含某一个结点++++++++")
    fmt.Println()
    fmt.Println("是否包含值为firstNode的结点：", list.Contain("firstNode"))
    print(list)
}

小白一枚，记录点滴成长，公众号：IT猿圈
主要记录：操作系统、计算机网络、编译原理、数据结构和算法

参考：
《数据结构与算法之美》

你可能感兴趣的:(golang,数据结构和算法,数据结构)

  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 4.C_数据结构_队列 荣世蓥 数据结构数据结构
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
  • 笋丁网页自动回复机器人V3.0.0免授权版源码 希希分享 软希网58soho_cn源码资源笋丁网页自动回复机器人
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • 【树一线性代数】005入门 Owlet_woodBird 算法
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
  • python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
    在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
  • 【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构leetcode算法
    给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • Golang语言基础知识点总结 最帅猪猪侠 golang开发语言后端
    Golang语言基础知识点小总结1.go语言有两大类型：值类型：数值类型，bool，string，数组，struct结构体变量直接存储值，内存通常在栈中分配,修改值,不会对源对象产生影响引用类型：指针，slice切片，管道chan，map，interface变量存储的是一个地址，这个地址对应的空间才真正存储数据值，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾
  • golang获取用户输入的几种方式 余生逆风飞翔 golang开发语言后端
    一、定义结构体typeUserInfostruct{Namestring`json:"name"`Ageint`json:"age"`Addstring`json:"add"`}typeReturnDatastruct{Messagestring`json:"message"`Statusstring`json:"status"`DataUserInfo`json:"data"`}二、get请求的
  • 【高阶数据结构】并查集 椿融雪 数据结构与算法数据结构并查集
    文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
  • 【Golang】实现 Excel 文件下载功能 RumIV Golanggolangexcel开发语言
    在当今的网络应用开发中，提供数据导出功能是一项常见的需求。Excel作为一种广泛使用的电子表格格式，通常是数据导出的首选格式之一。在本教程中，我们将学习如何使用Go语言和GinWeb框架来创建一个Excel文件，并允许用户通过HTTP请求下载该文件。准备工作在开始之前，请确保您的开发环境中已经安装了Go语言和相关的开发工具。此外，您还需要安装GinWeb框架和excelize包，这两个包都将用于我
  • golang 实现文件上传下载 wangwei830 go
    Gin框架上传下载上传（支持批量上传）httpRouter.POST("/upload",func(ctx*gin.Context){forms,err:=ctx.MultipartForm()iferr!=nil{fmt.Println("error",err)}files:=forms.File["fileName"]for_,v:=rangefiles{iferr:=ctx.SaveUplo
  • golang实现从服务器下载文件到本地指定目录 余生逆风飞翔 golang服务器开发语言
    一、连接服务器，采用sftp连接模式packagemiddlewaresimport("fmt""time""github.com/pkg/sftp""golang.org/x/crypto/ssh")//建立服务器连接funcConnect(user,password,hoststring,portint)(*sftp.Client,error){var(auth[]ssh.AuthMethod
  • 【Golang】 Golang 的 GORM 库中的 Rows 函数 不爱洗脚的小滕 golang开发语言后端
    文章目录前言一、Rows函数解释二、代码实现三、总结前言在使用Go语言进行数据库操作时，GORM（GoObject-RelationalMapping）库是一个常用的工具。它提供了一种简洁和强大的方式来处理数据库操作。本文将介绍GORM库中的Rows函数，这是一个用于执行原生SQL查询并返回结果的函数。一、Rows函数解释在GORM库中，Rows函数用于执行原生SQL查询并返回*sql.Rows结
  • 【Golang】使用 Golang 语言和 excelize 库将数据写入Excel 不爱洗脚的小滕 golangexcel开发语言
    文章目录前言一、Excelize简介二、代码实现1.获取依赖2.示例代码三、总结前言在数据处理和分析中，Excel作为一种常见的电子表格格式，被广泛应用于各种场景。然而，如何在Go语言中有效地处理Excel文件呢？在这篇博客中，我将介绍如何使用Go语言和excelize库将数据写入Excel文件。一、Excelize简介Excelize是一个用于读取和写入MicrosoftExcel™(XLSX)
  • python中文版软件下载-Python中文版 编程大乐趣
    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • 六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
    数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
  • Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
    Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
  • Go 面向包的设计和架构分层 云满笔记 golang架构directorylayoutsrcproject
    标题Go面向包的设计和架构分层序前项目架构分层工具包项目应用项目cmd/internal/internal/pkg/pkg/vendor/面向包的设计和验证包的位置依赖包导入应用级别的策略数据的发送和接收错误处理测试捕获错误不建议的目录结论Go面向包的设计和架构分层序本篇内容主要讲解golang项目的面向包设计准则和基础的架构分层。信息来自原文ArdanLabs:Package-Oriented-
  • Golang channel 死锁 羊城程序猿 golanggolang
    死锁是指两个或两个以上的协程的执行过程中，由于竞争资源或由于彼此通信而造成的一种阻塞的现象，若无外力作用，他们将无法推进下去,以下是总结出来的几种死锁情况。1.死锁1：一个通道在一个主go程里同时进行读和写2.死锁2：go程开启之前使用通道3.死锁3：通道1中调用了通道2，通道2中调用通道14.死锁4：直接读取空channel的死锁5.死锁5：超过channel缓存继续写入数据导致死锁6.向已关闭
  • golang学习笔记--MPG模型 xxzed golang#学习笔记学习笔记golang
    MPG模式：M（Machine）：操作系统的主线程P（Processor）：协程执行需要的资源（上下文context），可以看作一个局部的调度器，使go代码在一个线程上跑，他是实现从N：1到N：M映射的关键G（Goroutine）：协程，有自己的栈。包含指令指针（instructionpointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G1、当前程序有三个M,
  • 对于规范和实现，你会混淆吗？ yangshangchuan HotSpot
    昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息： JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
  • android 网络 百合不是茶 网络
    android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来  方便查找   ,  服务器使用的是TomCat   服务器代码;  servlet的使用需要在xml中注册 package servlet; import java.io.IOException; import java.util.Arr
  • [读书笔记]读法拉第传 comsci 读书笔记
          1831年的时候,一年可以赚到1000英镑的人..应该很少的...       要成为一个科学家,没有足够的资金支持,很多实验都无法完成       但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
  • 随机数的产生 沐刃青蛟 随机数
    c++中阐述随机数的方法有两种：   一是产生假随机数（不管操作多少次，所产生的数都不会改变）          这类随机数是使用了默认的种子值产生的，所以每次都是一样的。   //默认种子 for (int i = 0; i < 5; i++) { cout<<
  • PHP检测函数所在的文件名 IT独行者 PHP函数
    很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。 创建引用脚本。 代码：   [php]   view plain copy // Filename: functions.php    <?php&nbs
  • 银行各系统功能简介 文强chu 金融
    银行各系统功能简介 　 业务系统 核心业务系统 业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等 清分清算系统 以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程 国际结算系
  • Python学习1(pip django 安装以及第一个project) 小桔子 pythondjangopip
        最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！ 第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy! 第二部：解压这个压缩文件，会看到一个setup.p
  • php 数组 aichenglong PHP排序数组循环多维数组
    1 php中的创建数组 $product = array('tires','oil','spark');//array()实际上是语言结构而不  是函数 2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组 $numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10 $numbers=range(1,10,
  • 安装python2.7 AILIKES python
    安装python2.7 1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz 2、复制解压 #mkdir -p /opt/usr/python #cp  /opt/soft/Python-2
  • java异常的处理探讨 百合不是茶 JAVA异常
    //java异常  /* 1，了解java 中的异常处理机制，有三种操作 a,声明异常  b,抛出异常  c,捕获异常 2，学会使用try-catch-finally来处理异常 3，学会如何声明异常和抛出异常 4，学会创建自己的异常   */   //2，学会使用try-catch-finally来处理异常  
  • getElementsByName实例 bijian1013 element
    实例1： <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/x
  • 探索JUnit4扩展：Runner bijian1013 java单元测试JUnit
            参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。         文章地址：http://www.blogjava.net/jiangshachina/archive/20
  • [MongoDB学习笔记二]MongoDB副本集 bit1129 mongodb
    1. 副本集的特性   1)一台主服务器(Primary),多台从服务器(Secondary)   2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作   3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来   2
  • 【Spark八十一】Hive in the spark assembly bit1129 assembly
    Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners: 1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
  • Nginx问题定位之监控进程异常退出 ronin47
    nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。 1. 在error.log中查看是否有signal项，如果有，看看signal是多少。 比如，这是一个异常退出的情况： $grep signal error.log 2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
  • No grammar constraints (DTD or XML schema).....两种解决方法 byalias xml
    方法一：常用方法   关闭XML验证 工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。 方法二：（个人推荐） 添加 内容如下 <?xml version=
  • Netty源码学习-DefaultChannelPipeline bylijinnan netty
    package com.ljn.channel; /** * ChannelPipeline采用的是Intercepting Filter 模式 * 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现 * * 下面对ChannelPipeline作一个模拟，只模拟关键代码： */ public class Pipeline {
  • MYSQL数据库常用备份及恢复语句 chicony mysql
    备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。 mysqldump -h主机 -u用户名 -p密码 数据库名 > 文件 备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。 mysqldump -–add-drop-table -uusername -ppassword databasename > ba
  • 小白谈谈云计算--基于Google三大论文 CrazyMizzz Google云计算GFS
        之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。     我先说说GFS   &n
  • hadoop 平衡空间设置方法 daizj hadoopbalancer
    在hdfs-site.xml中增加设置balance的带宽，默认只有1M： <property>   <name>dfs.balance.bandwidthPerSec</name>     <value>10485760</value>     <description&g
  • Eclipse程序员要掌握的常用快捷键 dcj3sjt126com 编程
      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。 曾有人在豆瓣评 《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个 程序员图书列表，目的也就是通过读书，让程序员变懒。  程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
  • Android学习之路 dcj3sjt126com Android学习
    转自：http://blog.csdn.net/ryantang03/article/details/6901459 以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。 下面说说我学习Android的感受，我学Android首先是看MARS的视
  • java 遍历Map的四种方法 eksliang javaHashMapjava 遍历Map的四种方法
    转载请出自出处： http://eksliang.iteye.com/blog/2059996 package com.ickes; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; /** * 遍历Map的四种方式
  • 【精典】数据库相关相关 gengzg 数据库
    package C3P0; import java.sql.Connection; import java.sql.SQLException; import java.beans.PropertyVetoException; import com.mchange.v2.c3p0.ComboPooledDataSource; public class DBPool{
  • 自动补全 huyana_town 自动补全
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml&quo
  • jquery在线预览PDF文件，打开PDF文件 天梯梦 jquery
    最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。   核心代码 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
  • ViewPager刷新单个页面的方法 lovelease androidviewpagertag刷新
      使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
  • 利用按位取反（~）从复合枚举值里清除枚举值 草料场 enum
    以 C# 中的 System.Drawing.FontStyle 为例。   如果需要同时有多种效果， 如：“粗体”和“下划线”的效果，可以用按位或（|） FontStyle style = FontStyle.Bold | FontStyle.Underline;   如果需要去除 style 里的某一种效果，
  • Linux系统新手学习的11点建议 刘星宇 编程工作linux脚本
    　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。 　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
  • hibernate dao层应用之HibernateDaoSupport二次封装 wangzhezichuan DAOHibernate
    /** * <p>方法描述:sql语句查询 返回List<Class> </p> * <p>方法备注: Class 只能是自定义类 </p> * @param calzz * @param sql * @return * <p>创建人：王川</p> * <p>创建时间：Jul
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他