golang linked list reversal

Go language (Golang) is a programming language developed by Google. Its focus on simplicity, readability, efficiency and security makes it favored by more and more programmers. In Golang, linked list is one of the commonly used data structures. In actual development work, we may need to perform operations on the linked list, such as reversing the linked list. The following article will introduce how to implement linked list reversal in Golang.

The linked list is a basic data structure composed of nodes and pointers. Each node in the linked list contains a data item and a pointer to the next node. Due to the existence of pointers, operations on the linked list, such as reverse order, can be implemented simply by modifying the pointer's pointer without moving the elements.

First, we need to define a structure of linked list nodes:

<code class="go">type ListNode struct {
    Val  int
    Next *ListNode
}</code>

In the above structure, Val represents the value of the current node, and Next points to the next node. Next, we can implement the linked list reversal operation by defining a function:

<code class="go">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
}</code>

In the above function, we define two pointer variables prev and curr, and then reverse the linked list. In the specific implementation, we traverse the linked list, and for each node, we point the pointer curr to the node, and point the pointer prev to the previous node of curr. Then, we point the Next of the pointer curr to the pointer prev to implement the reverse order operation. After the traversal is completed, we return the pointer prev as the new head of the linked list to complete the reverse order of the linked list.

Next, we can write the main function to test the linked list inversion function:

<code class="go">func main() {
    head := &ListNode{Val: 1, Next: &ListNode{Val: 2, Next: &ListNode{Val: 3, Next: nil}}}
    fmt.Println("Original Linked List:")
    printList(head)
    fmt.Println("Reversed Linked List:")
    reversedHead := reverseList(head)
    printList(reversedHead)
}

func printList(head *ListNode) {
    for head != nil {
        fmt.Printf("%d->", head.Val)
        head = head.Next
    }
    fmt.Println("NULL")
}</code>

In the above code, we define a linked list containing three nodes, and then call the print linked list in sequence and the reverse linked list function. Finally, we can check whether the linked list was reversed correctly by running the program. The output is as follows:

<code>Original Linked List:
1->2->3->NULL
Reversed Linked List:
3->2->1->NULL</code>

This shows that in Golang, we have successfully implemented the reversal operation of the linked list.

To sum up, this article introduces how to implement linked list reversal operation in Golang. By defining a node structure and implementing a reverse order function, we can easily complete the reverse order of the linked list. In actual development, linked lists can often be used for complex problems, so it is very important to be proficient in linked list operations. If you have more interest in the Go language field, you can learn more about Golang and develop more efficient and maintainable applications.

The above is the detailed content of golang linked list reversal. For more information, please follow other related articles on the PHP Chinese website!