LeetCode 从头到尾打印链表
LeetCode 从头到尾打印链表
题目描述
输入一个链表头节点，从尾到头反过来返回每个节点的值（用数组返回）。
示例 1：
输入：head = [1,3,2]
输出：[2,3,1]
一得之见（Java/Python)
使用 list 顺序存放 head 的每个元素，然后创建一个 int 数组 result，长度为 list.size()，然后通过遍历将 list 的尾部元素即 list.get(size - i - 1)赋值给 result[i]，直至循环结束。
时间复杂度：O(n)，反向遍历一遍 list
空间复杂度：O(n)，使用一个 list 存储链表中的每个节点。
/**
* 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
*
* @param head 链表头结点
* @return 从尾到头反过来返回每个节点的值（用数组返回）
*/
public static int[] reversePrint(ListNode head) {
List<ListNode> list = new ArrayList<ListNode>();
ListNode temp = head;
while (temp != null) {
list.add(temp);
temp = temp.next;
}
int size = list.size();
int[] result = new int[size];
for (int i = 0; i < size; i++) {
result[i] = list.get(size - i - 1).val;
}
return result;
}
def reverse_print(head: ListNode) -> List[int]:
"""
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
:param head: 链表头结点
:return: 从尾到头反过来返回每个节点的值（用数组返回）
"""
head_list = []
temp = head
while temp is not None:
head_list.append(temp)
temp = temp.next
list_len = len(head_list)
result = [0 for i in range(list_len)]
for i in range(list_len):
result[i] = head_list[list_len - i - 1].val
return result
他山之石（Java/Python）
辅助栈法
栈的特点是后进先出，即最后压入栈的元素最先弹出。考虑到栈的这一特点，使用栈将链表元素顺序导致。从链表的头节点开始，依次将每个节点压入栈内，然后依次弹出栈内的元素并存储到数组中。
- 创建一个栈，用于存储链表的节点
- 创建一个指针，初始时指向链表的头节点
- 当指针指向的元素非空时，重复下列操作：
- 将指针指向的节点压入栈内
- 将指针移到当前节点的下一个节点
- 获得栈的大小 size，创建一个数组 print，其大小为 size
- 创建下标并初始化 index = 0
- 重复 size 次下列操作
- 从栈内弹出一个节点，将该节点的值存到 print[index]
- 将 index 的值加
- 返回 print
时间复杂度：O(n)，空间复杂度：O(n)
/**
* 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
*
* @param head 链表头结点
* @return 从尾到头反过来返回每个节点的值（用数组返回）
*/
public static int[] reversePrintTwo(ListNode head) {
Stack<ListNode> stack = new Stack<ListNode>();
ListNode temp = head;
while (temp != null) {
stack.push(temp);
temp = temp.next;
}
int size = stack.size();
int[] print = new int[size];
for (int i = 0; i < size; i++) {
print[i] = stack.pop().val;
}
return print;
}
}
def reverse_print_three(head: ListNode) -> List[int]:
"""
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
:param head: 链表头结点
:return: 从尾到头反过来返回每个节点的值（用数组返回）
"""
stack = []
while head:
stack.append(head.val)
head = head.next
return stack[::-1]
递归法
- 递推阶段：每次传入 head.next，以 head == None（即走过链表尾部节点）为递归终止条件，此时返回空列表[]
- 回溯阶段：利用 Python 语言特性，递归回溯时每次返回
当前list + 当前节点值[head.val]，即可实现节点的倒序输出。
时间复杂度：O(n)，空间复杂度：O(n)
def reverse_print_two(head: ListNode) -> List[int]:
"""
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
:param head: 链表头结点
:return: 从尾到头反过来返回每个节点的值（用数组返回）
"""
return reverse_print_two(head.next) + [head.val] if head else []
效率对比（Java）
输入：[0,1,3,2]
方法一：78800ns
方法二：111900ns
效率对比（Python）
输入：[0,1,3,2]
方法一：13200ns
方法二：24300ns
方法三：6300ns
其他知识点
[::-1]和[-1]用法
[::-1]顺序相反操作
[-1]读取倒数第一个元素
[3::-1]从下标为 3（到下标为 0 结束） 的元素开始翻转读取
链表
链表（Linked List）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针（Pointer）。
由于不必须按顺序存储，链表在插入的时候可以达到 O(1)的复杂度，比另一种线性表——顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要 O(n)的时间，而顺序表相应的时间复杂度为 O(log n) 和 O(1)。
基本机构
/**
* @author zhkai
*/
public class ListNode {
public int val;
public ListNode next;
public ListNode(int x) {
val = x;
}
}
创建链表
/**
* @author zhkai
*/
public class CreateListNode {
public static ListNode createListNode(int[] nums) {
int len = nums.length;
if (len < 1) {
return null;
}
// 创建首节点
ListNode nodeSta = new ListNode(nums[0]);
// 声明一个变量用来在移动过程中
ListNode nextNode;
// 指向首节点
nextNode = nodeSta;
// 创建链表
for (int i = 1; i < len; i++) {
// 生成新的节点
ListNode node = new ListNode(nums[i]);
// 把新的节点连接起来
nextNode.next = node;
// 当前节点往后移动
nextNode = nextNode.next;
}
// 当for循环完成之后，nextNode指向最后一个节点
nextNode = nodeSta;
return nextNode;
}
}
