golang反转单链表
时间: 2024-03-19 19:39:08 浏览: 25
在Golang中,可以使用迭代或递归的方式来反转单链表。以下是两种实现方法:
1. 迭代法[^2]:
```go
type ListNode struct {
Val int
Next *ListNode
}
func reverseList(head *ListNode) *ListNode {
var prev *ListNode
curr := head
for curr != nil {
next := curr.Next
curr.Next = prev
prev = curr
curr = next
}
return prev
}
```
2. 递归法:
```go
type ListNode struct {
Val int
Next *ListNode
}
func reverseList(head *ListNode) *ListNode {
if head == nil || head.Next == nil {
return head
}
p := reverseList(head.Next)
head.Next.Next = head
head.Next = nil
return p
}
```
相关问题
用golang实现单链表
可以使用以下代码实现单链表:
```
package main
import "fmt"
type Node struct {
data int
next *Node
}
type LinkedList struct {
head *Node
}
func (l *LinkedList) Add(data int) {
newNode := &Node{data: data}
if l.head == nil {
l.head = newNode
} else {
current := l.head
for current.next != nil {
current = current.next
}
current.next = newNode
}
}
func (l *LinkedList) Print() {
current := l.head
for current != nil {
fmt.Printf("%d ", current.data)
current = current.next
}
}
func main() {
list := LinkedList{}
list.Add(1)
list.Add(2)
list.Add(3)
list.Print()
}
```
这段代码实现了一个简单的单链表,包括添加节点和打印链表的功能。
golang 结构体数组 反转
在Go语言中,可以使用结构体数组来存储一具有相同结构的数据。要反转一个结构体数组,可以使用双指针的方法进行操作。具体步骤如下:
1. 定义一个结构体类型,例如:
```go
type Person struct {
Name string
Age int
}
```
2. 创建一个结构体数组,并初始化数据,例如:
```go
people := []Person{
{Name: "Alice", Age: 20},
{Name: "Bob", Age: 25},
{Name: "Charlie", Age: 30},
}
```
3. 使用双指针进行反转操作,代码如下:
```go
func reverse(people []Person) {
left := 0
right := len(people) - 1
for left < right {
people[left], people[right] = people[right], people[left]
left++
right--
}
}
reverse(people)
```
4. 反转后的结果可以通过遍历结构体数组来验证:
```go
for _, person := range people {
fmt.Println(person)
}
```
以上代码会输出反转后的结构体数组。