Golang程序 连接两个链表

在Go中，链表是一个线性数据结构，它包含一个节点，该节点进一步包含两个字段，一个是数据，另一个是下一个。下一个字段包含了延续中的下一个节点的地址。我们将在两种方法的帮助下执行这个程序。在第一种方法中，链接列表将被用作一系列的节点，在第二个例子中，不同的变量被用来执行程序。

方法1–使用链表作为一系列的节点

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

算法

• 第1步– 在程序中创建一个包main并声明fmt(format package)包，其中main产生可执行代码，fmt帮助格式化输入和输出。

• 第2步– 创建一个node类型的结构，其值为int类型，下一个指针为node类型。

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

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

• 第 5 步 – 查看其中一个链接列表是否为空；如果是，返回非空的链接列表。

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

• 第7步 – 使用当前指针浏览第一个链表，直到它到达当前。

• 第8步 – 后面是nil，标志着列表已经结束了。接下来是第二个链表的头部，l2，。接下来，返回第一个链表的 l1 的头部。

• 第9步 – 接下来的指针可以用来导航连接的链表，从头节点到尾节点。

• 第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 package)包，其中main产生可执行代码，fmt帮助格式化输入和输出。

• 第2步– 创建一个node类型的结构，其值为int类型，下一个指针为node类型。

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

• 第4步 – 调用函数 joinLists 并确定哪个链表是空的，如果是空的，返回非空的链表。

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

• 第6步 – 创建指针li1到第一个链表的头部。

• 第7步 – 直到li1，使用li1指针来导航第一个链表。

• 第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 

总结

我们用两个例子执行了连接两个链表的程序。在第一个例子中，我们将链表作为一系列的节点，在第二个例子中，我们做了类似的操作，但变量和类型不同。