Golang 连接两个链表

在Go中，链表是一种线性数据结构，它包含一个包含两个字段（数据和下一个节点的地址）的节点。下一个字段包含在连续中下一个节点的地址。我们将使用两种方法执行此程序。在第一种方法中，链表将被用作一系列节点，而在第二个示例中，不同的变量用于执行程序。

方法1 – 使用链表作为节点序列

这个程序将链表描述为一个节点的集合，每个节点都有一个值和指向列表中下一个节点的指针。joinLists函数将返回一个指向新列表头部的指针，该新列表是通过将第二个列表添加到第一个列表的末尾来创建的。为了演示目的，printList函数用于显示列表的内容。

步骤

• 第1步 - 在程序中创建一个main包并声明fmt（格式化包）包，其中main生成可执行代码，fmt帮助格式化输入和输出。

• 第2步 - 创建一个值为int类型的结构体node，以及类型为node的下一个指针。

• 第3步 - 在下一步中创建一个main函数，在该函数中创建要连接的两个链表。

• 第4步 - 在main中调用joinLists函数，并将两个列表作为输入。

• 第5步 - 检查其中一个链表是否为null；如果是，则返回非null链表。

• 第6步 - 创建一个指针，该指针被初始化为指向第一个链表l1的顶部。

• 第7步 - 使用当前指针导航第一个链表，直到它到达current。

• 第8步 - nil出现在其后，表示列表结束。第二个链表l2的头部紧随其后。然后，返回第一个链表的l1头部。

• 第9步 - 然后可以使用Next指针从头节点到尾节点导航连接的链表。

• 第10步 - 使用printList函数打印合并的链表，使用fmt.Println()函数执行语句，其中ln表示换行。

示例

在此示例中，我们将使用链表作为节点序列。

package main
import "fmt"
type Node struct {
   Value int
   Next  *Node
}

func main() {
   list1 := &Node{Value: 10, Next: &Node{Value: 20, Next: &Node{Value: 30}}}
   list2 := &Node{Value: 40, Next: &Node{Value: 50, Next: &Node{Value: 60}}}
   joinedList := joinLists(list1, list2)
   fmt.Println("The two lists are merged as follows:")
   printList(joinedList)   //print the merged list
}

func joinLists(li1, li2 *Node) *Node {
   if li1 == nil {
      return li2
   } else if li2 == nil {    //check if the list1 is null return list2 and vice-versa
      return li1
   }

   current := li1
   for current.Next != nil {
      current = current.Next 
   }
   current.Next = li2
   return li1
}

func printList(l *Node) {
   for l != nil {
      fmt.Printf("%d ", l.Value)
      l = l.Next
   }
   fmt.Println()
}

输出

The two lists are merged as follows:
10 20 30 40 50 60

方法2：使用不同类型的变量和它们在链表中的类型

这种方法使用与前面示例相同的基本方法，只是变量名称和类型有些变化。joinLists函数返回一个指向由将第二个列表添加到第一个列表末尾而创建的新列表的头部的指针，该函数需要两个链表作为参数。为了演示目的，使用printList函数显示列表的内容。

步骤

• 步骤1 - 在程序中创建一个main包并声明fmt(format包)包，main产生可执行代码，fmt用于格式化输入和输出。

• 步骤2 - 创建一个类型为node的结构体，其中包含类型为int的值和类型为node的下一个指针。

• 步骤3 - 在下一步中创建一个main函数，并在该函数中创建两个要连接的链表。

• 步骤4 - 调用joinLists函数并确定哪个链表为null，如果其中一个为null，则返回非null链表。

• 步骤5 - 创建一个指针，头部初始化为第一个链表li1。

• 步骤6 - 创建指向第一个链表的头部的指针li1。

• 步骤7 - 利用li1指针遍历第一个链表，直到li1为null。

• 步骤8 - 接下来是null，表示已经到达链表的末尾。

• 步骤9 - 将li1.next设置为li2。

• 步骤10 - 然后返回最上面的链表头。

• 步骤11 - 然后通过跟随Next指针，可以从头节点到尾节点遍历连接的链表。

示例

在这个示例中，我们将使用不同的变量和类型来继续执行。

package main
import "fmt"
type ListNode struct {
   Val  int
   Next *ListNode
}

func main() {
   list1 := &ListNode{Val: 10, Next: &ListNode{Val: 20, Next: &ListNode{Val: 30}}}
   list2 := &ListNode{Val: 40, Next: &ListNode{Val: 50, Next: &ListNode{Val: 60}}}

   joinedList := joinLists(list1, list2)  
   fmt.Println("The two linked lists are joined as follows:")
   printList(joinedList)  //print the lists merged
}

func joinLists(li1, li2 *ListNode) *ListNode {
   if li1 == nil {
      return li2
   } else if li2 == nil { //check if the list1 is null return list2 and vice-verca
      return li1
   }

   head := li1
   for li1.Next != nil {
      li1 = li1.Next
   }
   li1.Next = li2
   return head
}

func printList(l *ListNode) {
   for l != nil {
      fmt.Printf("%d ", l.Val)
      l = l.Next
   }
   fmt.Println()
}

输出

The two linked lists are joined as follows:
10 20 30 40 50 60

结论

我们通过两个示例执行了合并两个链表的程序。在第一个示例中，我们将链表作为一系列节点使用，在第二个示例中，我们执行了类似的操作，但使用了不同的变量和类型。