Golang程序 在链表的第一个和最后一个位置添加元素

在Golang中，一个链接列表是一个独特的数据结构，其中的节点有一个值，下一个指针指向下一个节点。列表的初始节点被称为头部，而列表的最后一个节点则指向nil，描述了列表的结束。我们将通过两个例子在链接列表的第一个和最后一个位置添加元素。在第一个例子中，将使用Node结构，在第二个例子中，将使用 ListNode 结构。

方法 1：使用Node结构

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

算法

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

• 第2步– 制作一个有两个字段的Node结构–data，它将保存节点的值；next，它将保存一个指向列表中它后面的节点的指针。

• 第3步 – 制作一个addFirst函数。一个节点应该首先被添加到链接列表的前面。列表的头部和要添加的数据是这个函数的两个输入。通过提供的数据，该函数生成一个新的节点，并将其下一个字段设置为列表的顶部，因为它是目前的。

• 第4步 – 该函数返回一个指向新节点的指针，该节点将作为列表的新头部。

• 第5步 – 要在链表的末端添加一个节点，创建函数 addLast。

• 第 6 步 – 列表的头部和要添加的数据是这个函数的两个输入。该函数从列表的顶部开始迭代，一直持续到底部。

• 第7步 – 然后，当前节点的下一个字段被设置为指向新的节点，然后用提供的数据创建一个新的节点。该函数返回列表的头部，该头部被单独留下。

• 第8步 – 为了打印链接列表的元素，创建函数printList。这个方法遍历列表，同时打印每个节点的数据字段的值。它把列表的头部作为一个参数。

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

• 第2步– 建立一个结构，ListNode包含两个字段–next用来存储指向列表中下一个节点的指针，data_val用来保存节点的值。

• 第3步 – 创建一个addFirst函数。一个节点应该首先被添加到链接列表的前面。列表的头部和要添加的值是这个函数的两个输入。

• 第 4 步 – 在下一步中，该函数接受一个值并产生一个新的节点，将下一个字段设置为列表头部，因为它是在那一刻。该函数返回一个指向新节点的指针，该节点将作为列表的新头部。

• 第5步 – 要在链表的末端添加一个节点，创建函数 addLast。列表的头部和要添加的值是这个函数的两个输入。

• 第6步 – 该函数从列表的顶部开始迭代，一直到底部。

• 第7步 – 当前节点的下一个字段被设置为指向新的节点，然后用指定的值创建一个新的节点。该函数返回列表的头部，该头部被单独留下。

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

结论

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