AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

go语言｜数据结构：单链表（2）

2023-05-25 155
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： go语言｜数据结构：单链表（2）

单向链表


　　又称单链表，单链表中每个结点包含两部分，分别是数据域和指针域，上一个结点的指针指向下一结点，依次相连，形成链表。三个概念：首元结点、头结点和头指针，其中头结点在链表中不是必须的。

e1e6a7b420f644f4b75de59df622c4b0.png


首元结点

就是链表中存储第一个元素的结点。


头结点

是在首元结点之前附设的一个结点，其指针域指向首元结点。头结点的数据域可以存储链表的长度或者其它的信息，也可以为空不存储任何信息。


头指针

是指向链表中第一个结点的指针。若链表中有头结点，则头指针指向头结点；若链表中没有头结点，则头指针指向首元结点。


链表与节点

引入单链表结构LinkList，仅保留头指针；与节点结构ListNode配合使用。头指针为空的单链表即为空链表，解决只使用节点结构不能构造空表的缺点。

type ListNode struct {
  data int
  next *ListNode
}
type LinkList struct {
  next *ListNode
}



插入单个元素

头插法pushHead() 、 尾插法pushTail()

package main
import "fmt"
type ListNode struct {
  data int
  next *ListNode
}
type LinkList struct {
  next *ListNode
}
func (head *LinkList) pushHead(value int) {
  node := &ListNode{data: value}
  node.next = head.next
  head.next = node
}
func (head *LinkList) pushTail(value int) {
  node := &ListNode{data: value}
  p := head.next
  if p != nil {
    for p.next != nil {
      p = p.next
    }
    p.next = node
  } else {
    head.next = node
  }
}
func (node *ListNode) travel() {
  for node != nil {
    fmt.Print(node.data)
    node = node.next
    if node != nil {
      fmt.Print("->")
    }
  }
  fmt.Println("<nil>")
}
func (head *LinkList) travel() {
  head.next.travel()
}
func main() {
  nodes := &LinkList{}
  nodes.travel()
  nodes.pushTail(1)
  nodes.travel()
  nodes.pushHead(2)
  nodes.pushHead(3)
  nodes.travel()
  nodes.pushTail(4)
  nodes.pushTail(5)
  nodes.travel()
}
/*输出：
<nil>
1<nil>
3->2->1<nil>
3->2->1->4->5<nil>
*/


数组插入链表

优化后插入多个元素：push()前插、append()追加

package main
import "fmt"
type Node struct {
  data int
  next *Node
}
type List struct {
  next *Node
}
func (head *List) push(list []int) {
  for i := len(list) - 1; i >= 0; i-- {
    node := &Node{data: list[i]}
    node.next = head.next
    head.next = node
  }
}
func (head *List) append(list []int) {
  for i := 0; i < len(list); i++ {
    node := &Node{data: list[i]}
    p := head.next
    if p != nil {
      for p.next != nil {
        p = p.next
      }
      p.next = node
    } else {
      head.next = node
    }
  }
}
func (head *List) travel() {
  node := head.next
  for node != nil {
    fmt.Print(node.data)
    node = node.next
    if node != nil {
      fmt.Print("->")
    }
  }
  fmt.Println("<nil>")
}
func main() {
  node1 := &List{}
  node1.travel()
  node1.push([]int{1, 2, 3, 5})
  node1.travel()
  node1.append([]int{7, 8, 9})
  node1.travel()
  node1.push([]int{-2, -1, 0})
  node1.travel()
  node2 := &List{}
  node2.travel()
  node2.append([]int{1, 2, 3, 5})
  node2.travel()
  node2.push([]int{-2, -1, 0})
  node2.travel()
  node2.append([]int{7, 8, 9})
  node2.travel()
}
/*输出：
<nil>
1->2->3->5<nil>
1->2->3->5->7->8->9<nil>
-2->-1->0->1->2->3->5->7->8->9<nil>
<nil>
1->2->3->5<nil>
-2->-1->0->1->2->3->5<nil>
-2->-1->0->1->2->3->5->7->8->9<nil>
*/



链表长度

package main
import "fmt"
type Node struct {
  data int
  next *Node
}
type List struct {
  next *Node
}
func Len(head *List) int {
  length := 0
  for p := head.next; p != nil; p = p.next {
    length++
  }
  return length
}
func (head *List) size() int {
  return Len(head)
}
func (head *List) build(list []int) {
  for i := len(list) - 1; i >= 0; i-- {
    node := &Node{data: list[i]}
    node.next = head.next
    head.next = node
  }
}
func main() {
  var node1, node2 *List
  node1 = new(List)
  node2 = new(List)
  fmt.Println(node1.size())
  node1.build([]int{1, 2, 3, 5})
  node2.build([]int{7, 8, 9})
  fmt.Println(node1.size())
  fmt.Println(Len(node2))
}
/*输出：
0
4
3
*/


链表副本

package main
import "fmt"
type Node struct {
  data int
  next *Node
}
type List struct {
  next *Node
}
func (head *List) Copy() *List {
  p := head.next
  list := &List{}
  node := &Node{p.data, nil}
  tail := node
  for p = p.next; p != nil; p = p.next {
    var linknode = Node{data: p.data}
    (*tail).next = &linknode
    tail = &linknode
  }
  list.next = node
  return list
}
func (head *List) build(list []int) {
  for i := len(list) - 1; i >= 0; i-- {
    node := &Node{data: list[i]}
    node.next = head.next
    head.next = node
  }
}
func (head *List) pushHead(value int) {
  node := &Node{data: value}
  node.next = head.next
  head.next = node
}
func (head *List) travel() {
  p := head.next
  for p != nil {
    fmt.Print(p.data)
    p = p.next
    if p != nil {
      fmt.Print("->")
    }
  }
  fmt.Println("<nil>")
}
func main() {
  var node1, node2 *List
  node1 = new(List)
  node2 = new(List)
  node1.build([]int{1, 2, 3, 5})
  node2 = node1
  node3 := node1.Copy() //保存副本
  node3.travel()
  node1.pushHead(0)
  node1.travel()
  node2.travel()
  node3.travel() //保存的副本不随node1变化
}
/*输出：
1->2->3->5<nil>
0->1->2->3->5<nil>
0->1->2->3->5<nil>
1->2->3->5<nil>
*/



链表拼接


Cat()追加

与尾插单个元素类似；另外拼接链表的副本有好处的，不信可把.Copy()去掉试试。

package main
import "fmt"
type Node struct {
  data int
  next *Node
}
type List struct {
  next *Node
}
func (head *List) Cat(node *List) {
  p := head.next
  q := node.Copy() //使用副本，确保node不变
  if p != nil {
    for p.next != nil {
      p = p.next
    }
    p.next = q.next
  } else {
    head.next = q.next
  }
}
func (head *List) Copy() *List {
  p := head.next
  list := &List{}
  node := &Node{p.data, nil}
  tail := node
  for p = p.next; p != nil; p = p.next {
    var linknode = Node{data: p.data}
    (*tail).next = &linknode
    tail = &linknode
  }
  list.next = node
  return list
}
func (head *List) build(list []int) {
  for i := len(list) - 1; i >= 0; i-- {
    node := &Node{data: list[i]}
    node.next = head.next
    head.next = node
  }
}
func (head *List) pushHead(value int) {
  node := &Node{data: value}
  node.next = head.next
  head.next = node
}
func (head *List) pushTail(value int) {
  node := &Node{data: value}
  p := head.next
  if p != nil {
    for p.next != nil {
      p = p.next
    }
    p.next = node
  } else {
    head.next = node
  }
}
func (head *List) travel() {
  p := head.next
  for p != nil {
    fmt.Print(p.data)
    p = p.next
    if p != nil {
      fmt.Print("->")
    }
  }
  fmt.Println("<nil>")
}
func main() {
  var node1, node2 *List
  node1 = new(List)
  node2 = new(List)
  node1.build([]int{1, 2, 3, 5})
  node2.build([]int{7, 8, 9})
  node3 := &List{}
  node3.Cat(node1)
  node3.Cat(node2)
  node3.travel()
  node1.travel()
  node2.travel()
}
/*输出：
1->2->3->5->7->8->9<nil>
1->2->3->5<nil>
7->8->9<nil>
*/



Add()左加

package main
import "fmt"
type Node struct {
  data int
  next *Node
}
type List struct {
  next *Node
}
func (head *List) Add(node *List) {
  q := node.Copy()
  p := q.next
  for p.next != nil {
    p = p.next
  }
  p.next = head.next
  head.next = q.next
}
func (head *List) Cat(node *List) {
  p := head.next
  q := node.Copy()
  if p != nil {
    for p.next != nil {
      p = p.next
    }
    p.next = q.next
  } else {
    head.next = q.next
  }
}
func (head *List) Copy() *List {
  p := head.next
  list := &List{}
  node := &Node{p.data, nil}
  tail := node
  for p = p.next; p != nil; p = p.next {
    var linknode = Node{data: p.data}
    (*tail).next = &linknode
    tail = &linknode
  }
  list.next = node
  return list
}
func (head *List) build(list []int) {
  for i := len(list) - 1; i >= 0; i-- {
    node := &Node{data: list[i]}
    node.next = head.next
    head.next = node
  }
}
func (head *List) pushHead(value int) {
  node := &Node{data: value}
  node.next = head.next
  head.next = node
}
func (head *List) pushTail(value int) {
  node := &Node{data: value}
  p := head.next
  if p != nil {
    for p.next != nil {
      p = p.next
    }
    p.next = node
  } else {
    head.next = node
  }
}
func (head *List) travel() {
  p := head.next
  for p != nil {
    fmt.Print(p.data)
    p = p.next
    if p != nil {
      fmt.Print("->")
    }
  }
  fmt.Println("<nil>")
}
func main() {
  var node1, node2 *List
  node1 = new(List)
  node2 = new(List)
  node1.build([]int{1, 2, 3, 5})
  node2.build([]int{7, 8, 9})
  node3 := &List{}
  node3.Add(node1)
  node3.travel()
  node3.Add(node2)
  node3.travel()
  node3.Add(node1)
  node3.travel()
  node3.Cat(node2)
  node3.travel()
  node1.travel()
  node2.travel()
}
/*输出：
1->2->3->5<nil>
7->8->9->1->2->3->5<nil>
1->2->3->5->7->8->9->1->2->3->5<nil>
1->2->3->5->7->8->9->1->2->3->5->7->8->9<nil>
1->2->3->5<nil>
7->8->9<nil>
*/


节点删除

节点删除需要判断链表自身是否为空链表，判断条件增加 if head.next == nil || p.next == nil {...}


删除首元结点

package main
import "fmt"
type Node struct {
  data int
  next *Node
}
type List struct {
  next *Node
}
func (head *List) delHead() {
  p := head.next
  if head.next == nil || p.next == nil {
    head.next = nil
  } else {
    head.next = p.next
  }
}
func (head *List) build(list []int) {
  for i := len(list) - 1; i >= 0; i-- {
    node := &Node{data: list[i]}
    node.next = head.next
    head.next = node
  }
}
func (head *List) travel() {
  for p := head.next; p != nil; p = p.next {
    fmt.Print(p.data)
    if p.next != nil {
      fmt.Print("->")
    }
  }
  fmt.Println("<nil>")
}
func main() {
  nodes := &List{}
  nodes.build([]int{1, 2, 3})
  nodes.travel()
  nodes.delHead()
  nodes.travel()
  nodes.delHead()
  nodes.travel()
  nodes.delHead()
  nodes.travel()
  nodes.delHead()
  nodes.travel()
}
/*输出：
1->2->3<nil>
2->3<nil>
3<nil>
<nil>
<nil>
*/


删除尾结点

package main
import "fmt"
type Node struct {
  data int
  next *Node
}
type List struct {
  next *Node
}
func (head *List) delTail() {
  p := head.next
  if head.next == nil || p.next == nil {
    head.next = nil
  } else {
    for p.next.next != nil {
      p = p.next
    }
    p.next = nil
  }
}
func (head *List) build(list []int) {
  for i := len(list) - 1; i >= 0; i-- {
    node := &Node{data: list[i]}
    node.next = head.next
    head.next = node
  }
}
func (head *List) travel() {
  for p := head.next; p != nil; p = p.next {
    fmt.Print(p.data)
    if p.next != nil {
      fmt.Print("->")
    }
  }
  fmt.Println("<nil>")
}
func main() {
  nodes := &List{}
  nodes.build([]int{1, 2, 3})
  nodes.travel()
  nodes.delTail()
  nodes.travel()
  nodes.delTail()
  nodes.travel()
  nodes.delTail()
  nodes.travel()
  nodes.delTail()
  nodes.travel()
}
/*输出：
1->2->3<nil>
1->2<nil>
1<nil>
<nil>
<nil>
*/


习题解答


1. 给定一个已排序链表，删除重复节点，原始链表中多次出现的数字只能保留一次。


示例1

输入: 1->1->2

输出: 1->2

示例2

输入: 1->1->2->3->3

输出: 1->2->3


package main
import "fmt"
type Node struct {
  data int
  next *Node
}
type List struct {
  next *Node
}
func (head *List) removeDuplicates() {
  p := head.next
  node := &List{}
  data := p.data
  node.pushTail(data)
  for p != nil {
    if p.data != data {
      data = p.data
      node.pushTail(data)
    }
    p = p.next
  }
  head.next = node.next
}
func (head *List) pushTail(value int) {
  node := &Node{data: value}
  p := head.next
  if p != nil {
    for p.next != nil {
      p = p.next
    }
    p.next = node
  } else {
    head.next = node
  }
}
func (head *List) build(list []int) {
  for i := len(list) - 1; i >= 0; i-- {
    node := &Node{data: list[i]}
    node.next = head.next
    head.next = node
  }
}
func (head *List) clear() {
  head.next = nil
}
func (head *List) travel() {
  for p := head.next; p != nil; p = p.next {
    fmt.Print(p.data)
    if p.next != nil {
      fmt.Print("->")
    }
  }
  fmt.Println()
  //fmt.Println("<nil>")
}
func main() {
  nodes := &List{}
  nodes.build([]int{1, 1, 2})
  nodes.travel()
  nodes.removeDuplicates()
  nodes.travel()
  nodes.clear()
  nodes.build([]int{1, 1, 2, 3, 3})
  nodes.travel()
  nodes.removeDuplicates()
  nodes.travel()
  nodes.clear()
  nodes.build([]int{1, 2, 3, 3, 4, 4, 5})
  nodes.travel()
  nodes.removeDuplicates()
  nodes.travel()
  nodes.clear()
  nodes.build([]int{1, 1, 1, 2, 3, 3, 3})
  nodes.travel()
  nodes.removeDuplicates()
  nodes.travel()
}
/*输出：
1->1->2
1->2
1->1->2->3->3
1->2->3
1->2->3->3->4->4->5
1->2->3->4->5
1->1->1->2->3->3->3
1->2->3
*/


2. 给定一个排序链表，删除所有重复的节点，留原始链表有过重复的数字一个也不留。

示例1

输入: 1->2->3->3->4->4->5

输出: 1->2->5

示例2

输入: 1->1->1->2->3

输出: 2->3

package main
import "fmt"
type Node struct {
  data int
  next *Node
}
type List struct {
  next *Node
}
func (head *List) deleteDuplicates() {
  p := head.next
  node := &List{}
  if p.next == nil || p.data != p.next.data {
    node.pushTail(p.data)
  }
  if p.next != nil {
    data := p.data
    for p.next.next != nil {
      data = p.data
      p = p.next
      if data != p.data && p.data != p.next.data {
        node.pushTail(p.data)
      }
    }
    if p.data != p.next.data {
      node.pushTail(p.next.data)
    }
  }
  head.next = node.next
}
func (head *List) pushTail(value int) {
  node := &Node{data: value}
  p := head.next
  if p != nil {
    for p.next != nil {
      p = p.next
    }
    p.next = node
  } else {
    head.next = node
  }
}
func (head *List) build(list []int) {
  for i := len(list) - 1; i >= 0; i-- {
    node := &Node{data: list[i]}
    node.next = head.next
    head.next = node
  }
}
func (head *List) clear() {
  head.next = nil
}
func (head *List) travel() {
  for p := head.next; p != nil; p = p.next {
    fmt.Print(p.data)
    if p.next != nil {
      fmt.Print("->")
    }
  }
  fmt.Println("")
  //fmt.Println("<nil>")
}
func main() {
  nodes := &List{}
  nodes.build([]int{1, 1, 1, 2, 3})
  nodes.travel()
  nodes.deleteDuplicates()
  nodes.travel()
  nodes.clear()
  nodes.build([]int{1, 2, 3, 3, 4, 4, 5})
  nodes.travel()
  nodes.deleteDuplicates()
  nodes.travel()
  nodes.clear()
  nodes.build([]int{1, 1, 2, 3, 3, 4, 5})
  nodes.travel()
  nodes.deleteDuplicates()
  nodes.travel()
  nodes.clear()
  nodes.build([]int{1, 2, 3, 3, 4, 5, 5})
  nodes.travel()
  nodes.deleteDuplicates()
  nodes.travel()
}
/*输出：
1->1->1->2->3
2->3
1->2->3->3->4->4->5
1->2->5
1->1->2->3->3->4->5
2->4->5
1->2->3->3->4->5->5
1->2->4
*/

3. 给定两个有序链表(升序)，合并为一个新的有序链表并返回。

   示例1

   输入：1->2>4->8

     　1->3->3->5->5

   输出：1->1->2->3->3->4->5->5->8

   示例2

   输入：0->2>4->8

     　1->3->5->7->9

   输出：0->1->2->3->4->5->6->7->8->9


1、递归法：

package main
import "fmt"
type Node struct {
  data int
  next *Node
}
type List struct {
  head *Node
}
//递归法合并有序链表
func recurMerge(p1 *Node, p2 *Node) *Node {
  if p1 == nil {
    return p2
  }
  if p2 == nil {
    return p1
  }
  p := new(Node)
  if p1.data < p2.data {
    p = p1
    p.next = recurMerge(p1.next, p2)
  } else {
    p = p2
    p.next = recurMerge(p1, p2.next)
  }
  return p
}
func (list *List) build(lst []int) {
  for i := len(lst) - 1; i >= 0; i-- {
    node := &Node{data: lst[i]}
    node.next = list.head
    list.head = node
  }
}
func (list *List) Copy() *List {
  p := list.head
  res := &List{}
  if p != nil {
    node := &Node{p.data, nil}
    q := node
    for p = p.next; p != nil; p = p.next {
      q.next = &Node{p.data, nil}
      q = q.next
    }
    res.head = node
  }
  return res
}
func (list *List) travel() {
  for p := list.head; p != nil; p = p.next {
    fmt.Print(p.data)
    if p.next != nil {
      fmt.Print("->")
    }
  }
  fmt.Println("<nil>")
}
func main() {
  List1 := &List{}
  List2 := &List{}
  List1.build([]int{1, 2, 4, 8})
  List2.build([]int{1, 3, 3, 5, 5})
  node1 := List1.Copy().head
  node2 := List2.Copy().head
  List0 := &List{}
  List0.head = recurMerge(node1, node2)
  List0.travel()
  List1.travel()
  List2.travel()
  //不使用副本的对比
  node1 = List1.head
  node2 = List2.head
  List0 = &List{}
  List0.head = recurMerge(node1, node2)
  List0.travel()
  List1.travel()
  List2.travel()
  //另一组合并
  List1 = &List{}
  List2 = &List{}
  List1.build([]int{0, 2, 4, 8})
  List2.build([]int{1, 3, 5, 7, 9})
  node1 = List1.Copy().head
  node2 = List2.Copy().head
  List0 = &List{}
  List0.head = recurMerge(node1, node2)
  List0.travel()
  List1.travel()
  List2.travel()
}
/*输出：
1->1->2->3->3->4->5->5->8<nil>
1->2->4->8<nil>
1->3->3->5->5<nil>
1->1->2->3->3->4->5->5->8<nil>
1->2->3->3->4->5->5->8<nil>
1->1->2->3->3->4->5->5->8<nil>
0->1->2->3->4->5->7->8->9<nil>
0->2->4->8<nil>
1->3->5->7->9<nil>
*/



本例中链表类的next指针改名为head：

type List struct {
    head *Node
}


2、常规遍历：

1.


package main
import "fmt"
type Node struct {
  data int
  next *Node
}
type List struct {
  head *Node
}
func mergeLists(list1 *List, list2 *List) *List {
  list := &List{&Node{}} //初始赋值时多余一个默认值0
  p := list.head
  p1 := list1.Copy().head  //使用副本保留链表原样
  p2 := list2.Copy().head
  for ; p1 != nil && p2 != nil; p = p.next {
    if p1.data < p2.data {
      p.next = p1
      p1 = p1.next
    } else {
      p.next = p2
      p2 = p2.next
    }
  }
  if p1 == nil {
    p.next = p2
  } else if p2 == nil {
    p.next = p1
  }
  list.head = list.head.next //去掉初始化时的0值
  return list
}
func (list *List) build(lst []int) {
  for i := len(lst) - 1; i >= 0; i-- {
    node := &Node{data: lst[i]}
    node.next = list.head
    list.head = node
  }
}
func (list *List) Copy() *List {
  p := list.head
  res := &List{}
  if p != nil {
    node := &Node{p.data, nil}
    q := node
    for p = p.next; p != nil; p = p.next {
      q.next = &Node{p.data, nil}
      q = q.next
    }
    res.head = node
  }
  return res
}
func (list *List) travel() {
  for p := list.head; p != nil; p = p.next {
    fmt.Print(p.data)
    if p.next != nil {
      fmt.Print("->")
    }
  }
  fmt.Println("<nil>")
}
func main() {
  List1 := &List{}
  List2 := &List{}
  List1.build([]int{1, 2, 4, 8})
  List2.build([]int{1, 3, 3, 5, 5})
  List0 := mergeLists(List1, List2)
  List0.travel()
  List1.travel()
  List2.travel()
  List1 = &List{}
  List2 = &List{}
  List1.build([]int{0, 2, 4, 8})
  List2.build([]int{1, 3, 5, 7, 9})
  List0 = mergeLists(List1, List2)
  List0.travel()
  List1.travel()
  List2.travel()
}
/*输出：
1->1->2->3->3->4->5->5->8<nil>
1->2->4->8<nil>
1->3->3->5->5<nil>
0->1->2->3->4->5->7->8->9<nil>
0->2->4->8<nil>
1->3->5->7->9<nil>
*/


2e5a4dee1e3d422387f478ad5b1a29b2.png


文章标签：
Go
存储
关键词：
Go语言
语言数据结构
数据结构go
Go数据结构
go语言数据结构
HannYang
目录
相关文章
蓝易云
|
3月前
|
消息中间件 缓存 NoSQL
Redis各类数据结构详细介绍及其在Go语言Gin框架下实践应用
这只是利用Go语言和Gin框架与Redis交互最基础部分展示；根据具体业务需求可能需要更复杂查询、事务处理或订阅发布功能实现更多高级特性应用场景。
蓝易云
286 86
凉凉心.
|
2月前
|
存储 安全 Java
【Golang】（4）Go里面的指针如何？函数与方法怎么不一样？带你了解Go不同于其他高级语言的语法
结构体可以存储一组不同类型的数据，是一种符合类型。Go抛弃了类与继承，同时也抛弃了构造方法，刻意弱化了面向对象的功能，Go并非是一个传统OOP的语言，但是Go依旧有着OOP的影子，通过结构体和方法也可以模拟出一个类。
凉凉心.
171 1
跃@sir
|
4月前
|
Cloud Native 安全 Java
Go：为云原生而生的高效语言
Go：为云原生而生的高效语言
跃@sir
289 1
跃@sir
|
4月前
|
Cloud Native Go API
Go：为云原生而生的高效语言
Go：为云原生而生的高效语言
跃@sir
376 0
跃@sir
|
4月前
|
Cloud Native Java Go
Go：为云原生而生的高效语言
Go：为云原生而生的高效语言
跃@sir
241 0
跃@sir
|
4月前
|
Cloud Native Java 中间件
Go：为云原生而生的高效语言
Go：为云原生而生的高效语言
跃@sir
218 0
跃@sir
|
4月前
|
Cloud Native Java Go
Go：为云原生而生的高效语言
Go：为云原生而生的高效语言
跃@sir
312 0
程序员爱钓鱼
|
4月前
|
数据采集 Go API
Go语言实战案例:多协程并发下载网页内容
本文是《Go语言100个实战案例 · 网络与并发篇》第6篇，讲解如何使用 Goroutine 和 Channel 实现多协程并发抓取网页内容，提升网络请求效率。通过实战掌握高并发编程技巧，构建爬虫、内容聚合器等工具，涵盖 WaitGroup、超时控制、错误处理等核心知识点。
程序员爱钓鱼
178 0
程序员爱钓鱼
|
4月前
|
数据采集 JSON Go
Go语言实战案例：实现HTTP客户端请求并解析响应
本文是 Go 网络与并发实战系列的第 2 篇，详细介绍如何使用 Go 构建 HTTP 客户端，涵盖请求发送、响应解析、错误处理、Header 与 Body 提取等流程，并通过实战代码演示如何并发请求多个 URL，适合希望掌握 Go 网络编程基础的开发者。
程序员爱钓鱼
502 0

热门文章

最新文章

  • 1
    （Python基础）新时代语言！一起学习Python吧！（一）：认识Python、Py解释器作用；编写第一个Python程序；Python中的基本数据结构
  • 2
    （Pandas）Python做数据处理必选框架之一！（一）：介绍Pandas中的两个数据结构；刨析Series：如何访问数据；数据去重、取众数、总和、标准差、方差、平均值等；判断缺失值、获取索引...
  • 3
    编译时插桩，Go应用监控的最佳选择
  • 4
    【虚警检测】基于CA-CFAR（单元平均恒虚警）、GO-CFAR（最大选择恒虚警）、SO-CFAR（最小选择恒虚警）算法的恒虚警检测附Matlab代码
  • 5
    Go中遇到http code 206和302的获取数据的解决方案
  • 6
    Go语言标准包之json编码
  • 7
    2.go基础知识
  • 8
    【go语言】wait，why not safe
  • 9
    Go 包管理工具 govendor 使用指南
  • 10
    Go——小白学习之函数
  • 1
    232.用栈实现队列，225. 用队列实现栈
    152
  • 2
    栈区的非法访问导致的死循环(x64)
    126
  • 3
    Java 集合面试题从数据结构到 HashMap 源码剖析详解及长尾考点梳理
    311
  • 4
    Redis设计与实现——数据结构与对象
    331
  • 5
    快速排序-数据结构与算法
    550
  • 6
    16.1k star! 只需要DDL就能一键生成数据库关系图！开源神器ChartDB让你的数据结构"看得见"
    1663
  • 7
    java实现队列数据结构代码详解
    258
  • 8
    Java 中 .length 的使用方法：深入理解 Java 数据结构中的长度获取机制
    782
  • 9
    线性数据结构详解
    228
  • 10
    为什么要学习数据结构与算法
    205

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践
    • 下一篇
    全面了解阿里云OSS使用方法