LeetCode21:合并双个有序链表
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
ListNode dummy = new ListNode(-1),p = dummy;
ListNode p1 = list1,p2 = list2;
if(p1==null&&p2==null) {
return dump.next;
}
while(p1!=null&&p2!=null){
if(p1.val>p2.val){
p.next = p2;
p2 = p2.next;
}else{
p.next = p1;
p1 = p1.next;
}
p = p.next;
}
if(p1!=null){
p.next = p1;
}
if(p2!=null){
p.next = p2;
}
return dummy.next;
}
这道题首先要思考既然要用一个新的链表存放,必然要申请一个链表头,比较两个链表中各个元素谁大谁小?小的插入到p的后面(p是指向dump的指针,之后一直保持在新链表的最大的值) ,其次考虑循环什么时候结束?有两种情况一种是一个循环完,另一个没有。于是就有了上面的解答,最终返回的是dump.next,因为dump一开始申请的是特殊的元素
leetcode23:合并k个升序链表
有了上面的思考,如果说3个有序链表合并呢?k个呢?我们需要找到每个链表头进行比较,我们这次用优先级队列,最小堆的方法,将最小的元素添加到堆顶,判断优先级队列是否为空,不为空的话将最小值的节点的下一个元素添加到优先级队列中。
public ListNode mergeKLists(ListNode[] lists) {
if (lists.length==0) return null;
// 虚拟的头结点
ListNode dump = new ListNode(-1),p = dump;
// 优先级队列最小堆
PriorityQueue<ListNode> pq = new PriorityQueue<>(
lists.length,(a,b)->(a.val-b.val)
);
// 将k个链表的链表头节点加入到最小堆中
for(ListNode head:lists){
if(head!=null){
pq.add(head);
}
}
while(!pq.isEmpty()){
// 获得最小节点 结果插入到p后面
ListNode node = pq.poll();
p.next = node;
if(node.next!=null){
pq.add(node.next);
}
p = p.next;
}
return dump.next;
}
一、用栈实现队列
力扣第 232 题「 用栈实现队列」让我们实现的 API 如下
class MyQueue {
/** 添加元素到队尾 */
public void push(int x);
/** 删除队头的元素并返回 */
public int pop();
/** 返回队头元素 */
public int peek();
/** 判断队列是否为空 */
public boolean empty();
}
我们使用两个栈 s1, s2 就能实现一个队列的功能(这样放置栈可能更容易理解):
class MyQueue {
private Stack<Integer> s1, s2;
public MyQueue() {
s1 = new Stack<>();
s2 = new Stack<>();
}
// ...
}
当调用 push 让元素入队时,只要把元素压入 s1 即可,比如说 push 进 3 个元素分别是 1,2,3,那么底层结构就是这样:
/** 添加元素到队尾 */
public void push(int x) {
s1.push(x);
}
那么如果这时候使用 peek 查看队头的元素怎么办呢?按道理队头元素应该是 1,但是在 s1 中 1 被压在栈底,现在就要轮到 s2 起到一个中转的作用了:当 s2 为空时,可以把 s1 的所有元素取出再添加进 s2,这时候 s2 中元素就是先进先出顺序了。
/** 返回队头元素 */
public int peek() {
if (s2.isEmpty())
// 把 s1 元素压入 s2
while (!s1.isEmpty())
s2.push(s1.pop());
return s2.peek();
}
同理,对于 pop 操作,只要操作 s2 就可以了。
/** 删除队头的元素并返回 */
public int pop() {
// 先调用 peek 保证 s2 非空
peek();
return s2.pop();
}
最后,如何判断队列是否为空呢?如果两个栈都为空的话,就说明队列为空:
/** 判断队列是否为空 */
public boolean empty() {
return s1.isEmpty() && s2.isEmpty();
}
至此,就用栈结构实现了一个队列,核心思想是利用两个栈互相配合。
值得一提的是,这几个操作的时间复杂度是多少呢?有点意思的是 peek 操作,调用它时可能触发 while 循环,这样的话时间复杂度是 O(N),但是大部分情况下 while 循环不会被触发,时间复杂度是 O(1)。由于 pop 操作调用了 peek,它的时间复杂度和 peek 相同。
像这种情况,可以说它们的最坏时间复杂度是 O(N),因为包含 while 循环,可能需要从 s1 往 s2 搬移元素。
但是它们的均摊时间复杂度是 O(1),这个要这么理解:对于一个元素,最多只可能被搬运一次,也就是说 peek 操作平均到每个元素的时间复杂度是 O(1)。
class MyQueue {
private Stack<Integer> a;
private Stack<Integer> b;
private Stack first = a
public MyQueue(){
a = new Stack<>();
b = new Stack<>();
}
// 压入第一个栈a
public void push(int x){
a.push(x);
}
//弹出栈b的元素
public int pop(){
if(b.isEmpty()){
while(!a.isEmpty()){
b.push(a.pop());
}
}
return b.pop();
}
public int peek() {
if(b.isEmpty()){
while(!a.isEmpty()){
b.push(a.pop());
}
}
return b.peek();
}
public boolean empty(){
return a.isEmpty()&&b.isEmpty();
}
}
二、用队列实现栈
如果说双栈实现队列比较巧妙,那么用队列实现栈就比较简单粗暴了,只需要一个队列作为底层数据结构。
力扣第 25 题「 用队列实现栈」让我们实现如下 API:
class MyStack {
/** 添加元素到栈顶 */
public void push(int x);
/** 删除栈顶的元素并返回 */
public int pop();
/** 返回栈顶元素 */
public int top();
/** 判断栈是否为空 */
public boolean empty();
}
先说 push 的API,直接将元素加入队列,同时记录队尾元素,因为队尾元素相当于栈顶元素,如果要 top 查看栈顶元素的话可以直接返回:
class MyStack {
Queue<Integer> q = new LinkedList<>();
int top_elem = 0;
/** 添加元素到栈顶 */
public void push(int x) {
// x 是队列的队尾,是栈的栈顶
q.offer(x);
top_elem = x;
}
/** 返回栈顶元素 */
public int top() {
return top_elem;
}
}
我们的底层数据结构是先进先出的队列,每次 pop 只能从队头取元素;但是栈是后进先出,也就是说 pop API 要从队尾取元素
解决方法简单粗暴,把队列前面的都取出来再加入队尾,让之前的队尾元素排到队头,这样就可以取出了:
/** 删除栈顶的元素并返回 */
public int pop() {
int size = q.size();
while (size > 1) {
q.offer(q.poll());
size--;
}
// 之前的队尾元素已经到了队头
return q.poll();
}
这样实现还有一点小问题就是,原来的队尾元素被提到队头并删除了,但是 top_elem 变量没有更新,我们还需要一点小修改:
/** 删除栈顶的元素并返回 */
public int pop() {
int size = q.size();
// 留下队尾 2 个元素
while (size > 2) {
q.offer(q.poll());
size--;
}
// 记录新的队尾元素
top_elem = q.peek();
q.offer(q.poll());
// 删除之前的队尾元素
return q.poll();
}
最后,API empty 就很容易实现了,只要看底层的队列是否为空即可
/** 判断栈是否为空 */
public boolean empty() {
return q.isEmpty();
}
很明显,用队列实现栈的话,pop 操作时间复杂度是 O(N),其他操作都是 O(1)。
总结用栈实现队列:从栈 s1 搬运元素到 s2 之后,元素在 s2 中就变成了队列的先进先出顺序,这个特性有点类似「负负得正」
除此之外看到网上博客里还有更好的答案:
https://www.cnblogs.com/wanghui9072229/archive/2011/11/22/2259391.html