数据结构
网络
RDBMS
操作系统
Java
MS Excel
iOS
HTML
CSS
Android
Python
C语言编程
C++
C#
MongoDB
MySQL
Javascript
PHP
物理学
化学
生物学
数学
英语
经济学
心理学
社会学
时尚研究
法律研究Go语言程序连接两个链表
在 Go 中，链表是一种线性数据结构，包含一个节点，该节点进一步包含两个字段，一个是数据，另一个是 next。next 包含后续节点的地址。我们将借助两种方法执行此程序。在第一种方法中，链表将被用作一系列节点，在第二个示例中，使用不同的变量来执行程序。
方法 1 - 使用链表作为一系列节点
此程序将链表描述为节点的集合，每个节点都具有一个 Value 和指向列表中下一个节点的指针。joinLists 函数需要两个链表作为参数，并返回一个指向新列表头的指针，该新列表是通过将第二个列表添加到第一个列表的末尾创建的。为了演示目的，printList 函数用于显示列表的内容。
算法
步骤 1 - 创建一个 package main 并声明程序中的 fmt（格式化包）包，其中 main 生成可执行代码，fmt 帮助格式化输入和输出。
步骤 2 - 创建一个类型为 node 的结构体，其值为 int 类型，next 指针为 node 类型。
步骤 3 - 在下一步中，创建一个 main 函数，并在该函数中创建两个要连接的链表。
步骤 4 - 从 main 中调用 joinLists 函数，并将两个列表作为输入。
步骤 5 - 查看是否有任何一个链表为空；如果是，则返回非空链表。
步骤 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 - 创建一个 package main 并声明程序中的 fmt（格式化包）包，其中 main 生成可执行代码，fmt 帮助格式化输入和输出。
步骤 2 - 创建一个类型为 node 的结构体，其值为 int 类型，next 指针为 node 类型。
步骤 3 - 在下一步中，创建一个 main 函数，并在该函数中创建两个要连接的链表。
步骤 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
结论
我们使用两个示例执行了连接两个链表的程序。在第一个示例中，我们将链表用作一系列节点，在第二个示例中，我们执行了类似的操作，但使用了不同的变量和类型。
369 次查看
