leetcode21&&23

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