反转一个单链表-递归实现

示例

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

解题思路

使用递归方式实现 因为要将所有的节点压入栈，所有时间复杂度是O(n)
栈最多将存放n个节点，所以空间复杂度是O(n)
递归时有两个要点

1. 将所有的node压入栈的时候，一定要有一个边界条件
2. 在node出栈的时候，要将next节点置空，以保证最后的一个出栈的node next为nil，防止死循环

代码

package main

import "fmt"

func main() {
	node := newNode()
	p(node)
	nodeRev := revNode(node)
	p(nodeRev)
}

func p(n *Node) {
	for n != nil {
		fmt.Println(fmt.Sprintf("%+v", n))
		n = n.Next
	}
}

/*
  节点只能记录下一个节点，和本身的一些属性
*/
type Node struct {
	Next    *Node
	Current int
}

/*
  生成一个链表
  有两个要点
  1. 因为是单向链表，所以最早生成的应该是最后一个节点
  2. 单向链表需要使用地址，这样才可以反转
*/
func newNode() *Node {
	node5 := &Node{
		Current: 5,
		Next:    nil,
	}
	node4 := &Node{
		Current: 4,
		Next:    node5,
	}
	node3 := &Node{
		Current: 3,
		Next:    node4,
	}
	node2 := &Node{
		Current: 2,
		Next:    node3,
	}
	node1 := &Node{
		Current: 1,
		Next:    node2,
	}
	return node1
}

func revNode(n *Node) *Node {
	//压栈的边界条件是 节点没有下一个节点
	if n == nil || n.Next == nil {
		return n
	}
	//执行递归调用
	p := revNode(n.Next)
	//反转链
	n.Next.Next = n
	//将出栈的node的下一个节点置为nil，防止死循环
	n.Next = nil
	return p
}