这是我参与11月更文挑战的第4天,活动详情查看:2021最后一次更文挑战
从尾到头打印链表
输入一个链表的头节点,从尾到头反过来返回每个节点的值(用数组返回)。
示例 1:
输入:head = [1,3,2] 输出:[2,3,1]
限制:
0 <= 链表长度 <= 10000
题解
方法一:栈——Java
栈的特点是后进先出,即最后压入栈的元素最先弹出。
考虑到栈的这一特点,使用栈将链表元素顺序倒置。从链表的头节点开始,依次将每个节点压入栈内,然后依次弹出栈内的元素并存储到数组中。
创建一个栈,用于存储链表的节点
创建一个指针,初始时指向链表的头节点
当指针指向的元素非空时,重复下列操作:
将指针指向的节点压入栈内
将指针移到当前节点的下一个节点
获得栈的大小 size,创建一个数组 print,其大小为 size
创建下标并初始化 index = 0
重复 size 次下列操作:
从栈内弹出一个节点,将该节点的值存到 print[index]
将 index 的值加 1
class Solution {
public int[] reversePrint(ListNode head) {
LinkedList<Integer> stack = new LinkedList<Integer>();
while(head != null) {
stack.addLast(head.val);
head = head.next;
}
int[] res = new int[stack.size()];
for(int i = 0; i < res.length; i++)
res[i] = stack.removeLast();
return res;
}
}
时间复杂度:O(N)
空间复杂度:O(N)
方法二:递归法——Java
利用递归: 先走至链表末端,回溯时依次将节点值加入列表 ,这样就可以实现链表值的倒序输出。
递推阶段: 每次传入 head.next ,以 head == null(即走过链表尾部节点)为递归终止条件,此时直接返回。
回溯阶段: 层层回溯时,将当前节点值加入列表,即tmp.add(head.val)。
最终,将列表 tmp 转化为数组 res ,并返回即可。
class Solution {
ArrayList<Integer> tmp = new ArrayList<Integer>();
public int[] reversePrint(ListNode head) {
recur(head);
int[] res = new int[tmp.size()];
for(int i = 0; i < res.length; i++)
res[i] = tmp.get(i);
return res;
}
void recur(ListNode head) {
if(head == null) return;
recur(head.next);
tmp.add(head.val);
}
}
时间复杂度:O(N)
空间复杂度:O(N)
方法二:递归法——Go
递归法——Go版本
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func reversePrint(head *ListNode) []int {
if head == nil {
return nil
}
return appendData(head)
}
func appendData(head *ListNode) []int {
if head.Next != nil{
list := appendData(head.Next)
list = append(list, head.Val)
return list
}
return []int{head.Val}
}