Golang 在链表的首尾位置添加元素

在Golang中，链表是一种独特的数据结构，其中节点包含一个值和一个指向下一个节点的指针。链表的初始节点被称为头节点，而指向nil的链表的最后一个节点表示链表的末尾。我们将使用两个示例在链表的首尾位置添加元素。第一个示例将使用节点结构，第二个示例将使用ListNode结构。

方法1：使用节点结构

在此方法中，我们将使用节点结构在链表的给定位置添加元素。在这里，我们将创建两个方法addfirst和addlast方法，程序将在这两个方法中添加元素。

步骤

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

• 步骤2 − 创建一个Node结构，有两个字段data，用于保存节点的值，和next，用于保存指向列表中其后节点的指针。

• 步骤3 − 创建一个addFirst函数。首先要将节点添加到链表的开头。这个函数的两个输入是链表的头和要添加的数据。使用提供的数据，函数生成一个新节点，并将其next字段设置为当前顶部的列表。

• 步骤4 − 函数返回一个指向新节点的指针，该指针成为链表的新头。

• 步骤5 − 要将节点添加到链表的末尾，创建addLast函数。

• 步骤6 − 此函数的两个输入是链表的头和要添加的数据。该函数从顶部开始迭代列表，并继续，直到到达底部。

• 步骤7 − 然后，创建一个新节点，使用提供的数据创建新节点后，将当前节点的next字段设置为指向新节点。函数返回链表的头，保持不变。

• 步骤8 − 创建printList函数以打印链表的元素。此方法通过迭代列表并打印每个节点的data字段的值来完成。它以链表的头作为参数。

• 步骤9 − 在main函数中创建链表的头节点，并调用addFirst和addLast函数，分别将元素添加到链表的第一个和最后一个节点中。

• 步骤10 − 最后，使用printList方法显示连接列表的元素。

示例

在这个示例中，我们使用了节点结构在链表的第一个和最后一个位置添加元素。

package main
import "fmt"

type Node struct {    //create a node struct
   data_val int
   next   *Node
}

func addFirst(head *Node, data_val int) *Node {    //create addFirst to add element at first place 
   newNode := &Node{data_val: data_val}
   newNode.next = head
   return newNode
}

func addLast(head *Node, data_val int) *Node { //create addLast to add element at last place
   newNode := &Node{data_val: data_val}
   current := head
   for current.next != nil {
      current = current.next
   }
   current.next = newNode
   return head
}

func printList(head *Node) {
   current := head
   for current != nil {
      fmt.Printf("%d -> ", current.data_val)
      current = current.next
   }
   fmt.Println("nil")
}

func main() {
   head := &Node{data_val: 20}
   fmt.Println("The first and last elements are added as follows:")
   head = addFirst(head, 10)
   head = addLast(head, 30)
   printList(head)  //print the list
}

输出

The first and last elements are added as follows:
10 -> 20 -> 30 -> nil

方法2：使用ListNode结构

在这个方法中，我们将使用ListNode结构将元素添加到链表的指定位置。在这里，我们将创建addFirst和addLast两个方法，程序将在这两个方法中编写添加元素的代码。

步骤

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

• 步骤2 - 建立一个结构，ListNode包含两个字段 – next用于存储链表中下一个节点的指针，data_val用于存储节点的值。

• 步骤3 - 创建addFirst函数。该函数应该首先将一个节点添加到链表的前面。该函数的两个输入是链表的头和要添加的值。

• 步骤4 - 在下一步中，函数接收一个值并生成一个新的节点，将该节点的next字段设置为链表的头部（目前的头部）。函数返回一个指向新节点的指针，这个新节点成为链表的新头部。

• 步骤5 - 要将一个节点添加到链表的末尾，创建addLast函数。该函数的两个输入是链表的头和要添加的值。

• 步骤6 - 该函数从顶部开始遍历链表，直到到达底部。

• 步骤7 - 接着，创建一个带有指定值的新节点，然后将当前节点的next字段设置为指向新节点。函数返回链表的头部，它保持不变。

• 步骤8 - 要打印链表的元素，创建printList函数。该函数遍历链表使用链表的头部作为参数，并打印每个节点的val字段的值。

• 步骤9 - 在main函数中创建链表的头部节点，然后调用addFirst和addLast函数将元素添加到链表的第一个和最后一个节点。

• 步骤10 - 最后，使用printList方法显示连接链表的元素。

示例

在这个示例中，我们将使用ListNode结构将元素添加到链表的第一个和最后一个位置。

package main
import "fmt"

type ListNode struct { //create listnode struct
   data_val int
   next *ListNode
}

func addFirst(head *ListNode, data_val int) *ListNode {  //create addFirst function to add element at first place
   newNode := &ListNode{data_val: data_val}  
   newNode.next = head
   return newNode
}

func addLast(head *ListNode, data_val int) *ListNode { //create addLast function to add element at last place

   newNode := &ListNode{data_val: data_val}
   current := head
   for current.next != nil {
      current = current.next
   }
   current.next = newNode
   return head
}

func printList(head *ListNode) {
   current := head
   for current != nil {
      fmt.Printf("%d -> ", current.data_val)
      current = current.next
   }
   fmt.Println("nil")
}

func main() {
   head := &ListNode{data_val: 1}
   head = addFirst(head, 0)
   head = addLast(head, 2)
   fmt.Println("The first and last elements are added as follows:")
   printList(head)  //print the linked list
}

输出

The first and last elements are added as follows:
0 -> 1 -> 2 -> nil

结论

我们在链表中执行了两个示例，分别是在第一个位置和最后一个位置添加元素的程序。在第一个示例中，我们使用了node结构，在第二个示例中，我们使用了Listnode结构。