单链表翻转

思路一：借用新的单链表

新建一个新的单向链表，从头循环处理旧链表节点，依次插入到新单向链表的头节点，最后用新单向链表的头节点替换旧单向链表的头节点

package main

import (
	"fmt"
)

// 链表
type LinkList struct {
	HeadNode *LinkNode
}

//单向链表节点
type LinkNode struct {
	Data int32 // 链表上的数据
	Next *LinkNode // 指针指向下一个数据
}

// 在头部添加数据,把原来的头部替换掉,还需要把现在的元素指向原来的头部
func (self *LinkList) Add(value int32)  {
	node := &LinkNode{Data:value,}
	node.Next=self.HeadNode
	self.HeadNode = node
}

// 在尾部添加数据,需要从头部开始遍历,直到nil
func (self *LinkList)Append(value int32)  {
	newNode := &LinkNode{Data:value}
	node := self.HeadNode
	// 首部是空
	if node == nil {
		self.HeadNode = newNode
	} else {
		for node.Next != nil {
			node = node.Next
		}
		// 已经得到最后的元素
		node.Next = newNode
	}
}

// 循环链表输出元素
func (self *LinkList)forEachLink()  {
	node := self.HeadNode
	for node != nil {
		fmt.Printf("当前元素 :%v\n", node.Data)
		node = node.Next
	}
}
// 单链表翻转
func (self *LinkList)flip()  {
	linkList :=NewLinkList()
	node := self.HeadNode
	for node!=nil {
		linkList.Add(node.Data)
		node = node.Next
	}
	self.HeadNode=linkList.HeadNode
}

func NewLinkList() LinkList {
	linkList := LinkList{HeadNode:nil}
	return linkList
}

func main()  {
	linkList :=NewLinkList()
	for i:=0;i<7;i++{
		linkList.Append(int32(i))
	}
	linkList.forEachLink()
	linkList.flip()
	linkList.forEachLink()
}

记一道字节跳动的算法面试题 – 变形的链表反转