链表算法题(程序员面试宝典)
解题思路主要来源于leetcode官方与《程序员面试宝典》。
1019. 链表中的下一个更大节点
给出一个以头节点 head 作为第一个节点的链表。链表中的节点分别编号为:node_1, node_2, node_3, … 。
每个节点都可能有下一个更大值(next larger value):对于 node_i,如果其 next_larger(node_i) 是 node_j.val,那么就有 j > i 且 node_j.val > node_i.val,而 j 是可能的选项中最小的那个。如果不存在这样的 j,那么下一个更大值为 0 。
返回整数答案数组 answer,其中 answer[i] = next_larger(node_{i+1}) 。
注意:在下面的示例中,诸如 [2,1,5] 这样的输入(不是输出)是链表的序列化表示,其头节点的值为 2,第二个节点值为 1,第三个节点值为 5 。
示例 1:
输入:[2,1,5]
输出:[5,5,0]
示例 2:
输入:[2,7,4,3,5]
输出:[7,0,5,5,0]
示例 3:
输入:[1,7,5,1,9,2,5,1]
输出:[7,9,9,9,0,5,0,0]
提示:
对于链表中的每个节点,1 <= node.val <= 10^9
给定列表的长度在 [0, 10000] 范围内
解题方法
解题思路1
双循环遍历,找curNode后第一个比curNode.val大的节点node,找到的话,将int[i] = node.val,未找到的话 int[i] = 0。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public int[] nextLargerNodes(ListNode head) {
//存储结果
ArrayList<Integer> result = new ArrayList<Integer>();
//双循环遍历,将curNode与其后每一个节点
ListNode curNode = head;
while(curNode.next!=null){
ListNode node = curNode.next;
//flag: 标记是否找到curNode后第一个比curNode.val大的节点,true:yes false:no
boolean flag = false;
while(node!=null){
if(node.val>curNode.val){
//找到curNode后第一个最大
flag = true;
break;
}
node = node.next;
}
if(flag == true){
//找到curNode后第一个比curNode.val大的节点
result.add(node.val);
}else{
//未找到curNode后比curNode.val大的节点
result.add(0);
}
curNode = curNode.next;
}
result.add(0);
int[] resultInt = new int[result.size()];
for(int i=0;i<result.size();i++){
resultInt[i] = result.get(i);
}
return resultInt;
}
}
解题思路2
单调栈的思想。思路来源:https://labuladong.github.io/ebook/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%B3%BB%E5%88%97/%E5%8D%95%E8%B0%83%E6%A0%88.html
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public int[] nextLargerNodes(ListNode head) {
//存储链表值
ArrayList<Integer> data = new ArrayList<Integer>();
while(head!=null){
data.add(head.val);
head = head.next;
}
//存储结果
int[] result = new int[data.size()];
//单调栈的思想,栈用来存储节点值
Stack<Integer> s = new Stack<Integer>();
//data中的节点数
int num = data.size();
for(int i=num-1;i>=0;i--){
while(!s.empty()&&s.peek()<=data.get(i)){
//矮个子先出栈
s.pop();
}
//栈不为空说明有高个,即为当前result[i]的值,否则为无效值
result[i] = !s.empty()?s.peek():0;
//将当前data[i]值加入栈中
s.add(data.get(i));
}
return result;
}
}
解题思路3
单调栈的思想,遍历链表,从前往后压栈。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public int[] nextLargerNodes(ListNode head) {
//单调栈的思想
//存储节点的索引值
Stack<Integer> s = new Stack<Integer>();
//存储链表值
ArrayList<Integer> data = new ArrayList<Integer>();
//存储结果值
ArrayList<Integer> result = new ArrayList<Integer>();
int index = 0;
while(head!=null){
//先对结果当前位置填充上无效值0
result.add(0);
//将当前链表值添加到data中
data.add(head.val);
while(!s.empty()&&head.val>data.get(s.peek())){
//栈不为空且当前head.val大于栈顶索引值对应的节点值
//将s中存储的索引与head.val 对结果result的值进行更新
result.set(s.pop(),head.val);
}
//将当前索引值压栈
s.push(index);
index++;
head = head.next;
}
int[] resultInt = new int[result.size()];
for(int i=0;i<result.size();i++){
resultInt[i] = result.get(i);
}
return resultInt;
}
}