乱序版 ● 剑指offer每日算法题打卡题解—— 栈 （题号9,6,30）

Posted 2021-09-28 寂静花开

打卡day1
既然有目标了就要好好干呀！
从看懂题目开始。。。
剑指offer乱序版

目录

• • 第一题：剑指 Offer 09. 用两个栈实现队列
  • 第二题：剑指 Offer 30. 包含min函数的栈
  • 第三题：剑指 Offer 06. 从尾到头打印链表

第一题：剑指 Offer 09. 用两个栈实现队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：

输入： ["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
输出：[null,null,3,-1]

示例 2：

输入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof

题目理解：
总的来说，是需要实现两个函数。先看示例的输入。

["CQueue","appendTail","deleteHead","deleteHead"]
这一行表示每一行代码的操作

[[],[3],[],[]]
这个表示每一行代码操作所需要的参数

由题干信息可知：
CQueue 表示新建一个CQueue对象，对应的所需参数为 []，即此操作不需要参数。
appendTail 表示执行一个appendTail()操作，对应要被操作的元素为3。（在队列尾部插入整数3，3进栈，返回值为null）
deleteHead 表示执行一个deleteHead操作，对应的所需参数为 []，即此操作不需要参数。（此时栈底元素是3）
deleteHead 表示执行一个deleteHead操作，对应的所需参数为 []，即此操作不需要参数。（在队列头部删除，因为没有元素，所以返回-1）

以上的输入其实是一个代码执行的步骤描述与其对应所需参数。

解题思路
用一个栈 stack1 当作“队列”，另一个栈 stack2 用来辅助操作。
入队：直接进入栈1。
出队：如果栈2为空，将栈1的元素出栈，入栈到栈2；如果栈2不为空，栈2的元素出。

java代码

class CQueue {
    Deque<Integer> stack1;//创建栈1
    Deque<Integer> stack2;//创建栈2
    
    public CQueue() {
        stack1 = new LinkedList<Integer>();
        stack2 = new LinkedList<Integer>();
        //与ArrayList对比，LinkedList插入和删除操作更加高效，随机访问速度慢；
        //可以作为栈、队列、双端队列数据结构使用；非同步，线程不安全；
        //详细讲解：https://www.cnblogs.com/chenpi/p/5269737.html
    }
    
    public void appendTail(int value) {
        stack1.push(value);
    }
    
    public int deleteHead() {
        // 如果第二个栈为空
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {//当栈1不为空的时候进行循环
                stack2.push(stack1.pop());
            }
        } 
        if (stack2.isEmpty()) {
            return -1;
        } else {
            int deleteItem = stack2.pop();
            return deleteItem;
        }
    }
}
/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue obj = new CQueue();
 * obj.appendTail(value);
 * int param_2 = obj.deleteHead();
 */

第二题：剑指 Offer 30. 包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3); minStack.min(); --> 返回 -3.
minStack.pop(); minStack.top(); --> 返回 0.
minStack.min(); -->返回 -2.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/bao-han-minhan-shu-de-zhan-lcof

题目理解：
普通栈的 push() 和 pop() 函数的复杂度为 O(1) ；但是获取栈最小值 min() 函数需要遍历整个栈，复杂度为 O(N) ，题目要求将其复杂度降为 O(1) ，需要建立另一个栈来辅助。

解题思路
数据栈 stack1 ： stack1 用于存储所有元素，保证入栈 push() 函数、出栈 pop() 函数、获取栈顶 top() 函数的正常逻辑。
辅助栈 stack2 ： stack2用来存储stack1 中所有 非严格降序 的元素，则stack1 中的最小元素始终对应stack2的栈顶元素，所以min() 函数只需返回stack2的栈顶元素就行。

java代码

class MinStack {
    Stack<Integer> stack1;//创建数据栈
    Stack<Integer> stack2;//创建辅助栈
    
    public MinStack() {
    	stack1 = new Stack<>();
    	stack2 = new Stack<>();
    }
    public void push(int x) {
    	stack1.add(x);
        if(stack2.empty() || stack2.peek() >= x)
        	//peek()函数返回栈顶的元素，但不弹出该栈顶元素。
        	//pop()函数返回栈顶的元素，并且将该栈顶元素出栈。
        	stack2.add(x);
    }
    public void pop() {
        if(stack1.pop().equals(stack2.peek()))
        	stack2.pop();
    }
    public int top() {
        return stack1.peek();
    }
    public int min() {
        return stack2.peek();
    }
}

第三题：剑指 Offer 06. 从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2]
输出：[2,3,1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof

题目理解：
就是链表内容倒序输出

解题思路
链表特点： 只能从前至后访问每个节点。先进后出，以借助 栈 来实现。
java代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class PrintLinkedListFromEndToHead06 {
    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;
    }
}