Day3 Golang (链表) 203.移除链表元素 707.设计链表 206.反转链表_go语言var prev *listnode和pre := &listnode{}的区别

// 01 203.移除链表元素
package main
 
import "fmt"
 
//Definition for singly-linked list.定义链表的结构
type ListNode struct {
	Val  int
	Next *ListNode
}
 
func removeElements(head *ListNode, val int) *ListNode {
	dummyhead := new(ListNode)          //定义一个虚拟头结点
	dummyhead.Next = head               //虚拟头结点指向链表的头结点
	cur := dummyhead                    //定义临时指针用来遍历链表
	for cur.Next != nil { /下一个结点指针也不为空,由于需要cur.Next.Next
		if cur.Next.Val == val {
			cur.Next = cur.Next.Next
		} else {
			cur = cur.Next
		}
	}
	return dummyhead.Next //注意这里返回虚拟头结点的下一个结点，因为头结点可能会被删除
}
func printList(cur *ListNode) { //打印链表元素
	for cur != nil {
		fmt.Printf("%v ", cur.Val)
		cur = cur.Next
	}
	fmt.Println("")
}
func main() {
	node1, node2, node3 := new(ListNode), new(ListNode), new(ListNode)
	node4, node5, node6, node7 := new(ListNode), new(ListNode), new(ListNode), new(ListNode)
	//结点1-3
	node1.Val, node2.Val, node3.Val = 1, 2, 6
	node1.Next, node2.Next, node3.Next = node2, node3, node4
	//结点4-7
	node4.Val, node5.Val, node6.Val, node7.Val = 3, 4, 5, 6
	node4.Next, node5.Next, node6.Next, node7.Next = node5, node6, node7, nil
 
	cur := node1 //cur用来遍历链表
	printList(cur)
	res := removeElements(node1, 6) //移除链表元素
	printList(res)
 
}

 注意：

1.初始化链表的方法 dummyhead : = &ListNode{Val:val} 或 dummyhead : =new(ListNode)

2.返回值为 dummy.Next 不是 head

3.删除头结点时用 for 而不是 if，避免出现[1,1,1,1,1] 只删除一个结点的情况

4.因为要对 cur.next.next 操作，须先判断 cur.next 不为空

// 02 707.设计链表
package main
 
import (
	"fmt"
)
 
type SingleNode struct {
	Val  int
	Next *SingleNode
}
 
type MyLinkedList struct {
	Dummyhead *SingleNode //链表头结点的地址
	Size      int         //链表的长度
}
 
func Constructor() MyLinkedList {
	node := &SingleNode{0, nil} //定义一个虚拟头结点
	return MyLinkedList{node, 0}
}
 
func (this *MyLinkedList) Get(index int) int {
	if index < 0 || index > this.Size-1 { //注意提前判断index是否合法
		return -1
	}
	cur := this.Dummyhead
	for index > 0 {
		cur = cur.Next
		index--
	}
	return cur.Next.Val
}
 
func (this *MyLinkedList) AddAtHead(val int) {
	cur := this.Dummyhead
	newnode := &SingleNode{val, nil}
	newnode.Next = cur.Next
	cur.Next = newnode
	this.Size++
 
}
 
func (this *MyLinkedList) AddAtTail(val int) {
	cur := this.Dummyhead
	newnode := &SingleNode{val, nil}
	for cur.Next != nil {
		cur = cur.Next
	}
	cur.Next = newnode
	this.Size++
}
 
func (this *MyLinkedList) AddAtIndex(index int, val int) {
	if index < 0 || index > this.Size { //注意提前判断index是否合法，这里index可以等于this.Size
		return
	}
	cur := this.Dummyhead
	newnode := &SingleNode{val, nil}
	for index > 0 {
		cur = cur.Next
		index--
	}
	newnode.Next = cur.Next
	cur.Next = newnode
	this.Size++
}
 
func (this *MyLinkedList) DeleteAtIndex(index int) {
	if index < 0 || index > this.Size-1 { //注意提前判断index是否合法
		return
	}
	cur := this.Dummyhead
	for index > 0 {
		cur = cur.Next
		index--
	}
	cur.Next = cur.Next.Next
	this.Size--
}
 
func printList(cur *SingleNode) { //打印链表元素
	for cur != nil {
		fmt.Printf("%v ", cur.Val)
		cur = cur.Next
	}
	fmt.Println("")
}
 
 
func main() {
	list := Constructor()
	list.AddAtHead(100)
	list.AddAtHead(200)
	list.AddAtHead(300)
	printList(list.Dummyhead.Next) //头插法：初始化一个链表 300 200 100
	list.AddAtHead(1)              //在头结点后插入元素
	printList(list.Dummyhead.Next) //1 300 200 100
	list.AddAtTail(3)              //在尾结点后插入元素
	printList(list.Dummyhead.Next) //1 300 200 100 3
	list.AddAtIndex(1, 5)          //在索引为1的结点前插入元素，索引从0开始
	printList(list.Dummyhead.Next) //1 5 300 200 100 3
	list.DeleteAtIndex(3)          //删除索引为3的元素
	printList(list.Dummyhead.Next) //1 5 300 100 3
	res := list.Get(4)             //获取索引值为4的元素
	fmt.Printf("res: %v\n", res)   //res: 3
}

// 03 206.反转链表
package main
 
import "fmt"
 
type ListNode struct {
	Val  int
	Next *ListNode
}
 
func printList(cur *ListNode) { //打印链表元素
	for cur != nil {
		fmt.Printf("%v ", cur.Val)
		cur = cur.Next
	}
	fmt.Println("")
}
func reverseList(head *ListNode) *ListNode {
	var pre *ListNode //重点：定义一个指向链表的空指针
	cur := head
	for cur != nil { //cur指向kong循环结束
		temp := cur.Next //保存cur下一个结点的地址
		cur.Next = pre   //反转链表
		pre = cur        //先移动pre
		cur = temp       //再移动cur
	}
	return pre
}
 
func main() {
	node1, node2, node3 := new(ListNode), new(ListNode), new(ListNode)
	node4, node5, node6, node7 := new(ListNode), new(ListNode), new(ListNode), new(ListNode)
	//结点1-3
	node1.Val, node2.Val, node3.Val = 1, 2, 6
	node1.Next, node2.Next, node3.Next = node2, node3, node4
	//结点4-7
	node4.Val, node5.Val, node6.Val, node7.Val = 3, 4, 5, 6
	node4.Next, node5.Next, node6.Next, node7.Next = node5, node6, node7, nil
 
	cur := node1   //cur用来遍历链表
	printList(cur) //1 2 6 3 4 5 6
	res := reverseList(node1)
	printList(res) //6 5 4 3 6 2 1
}

注意：

1.这里初始化 pre 为 空指针类型 var pre*ListNode，不能初始化为结点（错误写法pre:=new(ListNode)）

2. 首先用 temp 保存 cur.Next，再翻转链表 cur.Next 指向 pre，然后先让 pre 指向 cur，再让 cur 指向 temp 保存的值。