剑指offer刷题（栈、堆、 队列、 图）

Stack & Queue

005-用两个栈实现队列

题目描述

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

题解

用两个栈来实现队列（先进先出）的功能

• stack1：实现push 操作
  
  - 直接添加到stack1中

• stack2：实现pop操作
  
  1. stack1和Stack2 均而空，返回 -1；
  
  2.若 stack2 为空（有上面条件知stack1不为空）
  
  - 遍历stack1，将stack1中的元素添加到stack2中
  
  3.只要stack2不为空，弹出stack2栈顶的元素；

代码

import java.util.Stack;
public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    //push 是从队列的头部插入元素
    public void push(int node) {
        stack1.add(node);
    }
    // pop() 是从队列的尾部取出元素
    public int pop() {
        if(stack1.isEmpty() && stack2.isEmpty()){
            return -1;
        }
        if(stack2.isEmpty()){
            while(!stack1.isEmpty()){
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
}

复杂度

由于问题特殊，以下分析仅满足添加 N 个元素并删除 N 个元素，即栈初始和结束状态下都为空的情况。

• 时间复杂度： push函数为 O(1)；pop()函数在N次队首元素删除操作中总共需完成N个元素的倒序。

• 空间复杂度O(N)：最差情况下，栈1和2共保存N个元素。

020-包含min函数的栈021-栈的压入、弹出序列

题目描述

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 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.

题解

知识点：

• dd & push

共同点：add，push都可以向stack中添加元素。

不同点：

`add`是继承自Vector的方法，且返回值类型是boolean.

`push`是Stack自身的方法，返回值类型是参数类类型。

• peek & pop

共同点：peek，pop都是返回栈顶元素。

不同点：

peek()函数返回栈顶的元素，但不弹出该栈顶元素。
pop()函数返回栈顶的元素，并且将该栈顶元素出栈。

函数设计：

• push(x) 函数： 重点为保持栈 B 的元素是 非严格降序 的。

1. 将 x 压入栈 A（即 A.add(x) ）；

2. 若 ① 栈 B 为空 或 ② x 小于等于 栈 B 的栈顶元素，则将 x 压入栈 B （即 B.add(x) ）。

• pop() 函数： 重点为保持栈 A,B 的 元素一致性 。

1. 执行栈 A 出栈（即 A.pop() ），将出栈元素记为 y ；
2. 若 y等于栈 B 的栈顶元素，则执行栈 B 出栈（即 B.pop() ）。

• top() 函数： 直接返回栈 A 的栈顶元素即可，即返回 A.peek() 。

• min() 函数： 直接返回栈 B 的栈顶元素即可，即返回 B.peek() 。

代码

class MinStack {
    Stack<Integer> stack;//c存储数据
    Stack<Integer> stackMin;//存储最小值
    /** initialize your data structure here. */
    public MinStack() {
      stack = new Stack<>();
      stackMin = new Stack<>();
    }

    public void push(int x) {
        stack.push(x);//将x压入存储栈stack中；
        //当stackMin为空或者当前x小于栈顶元素（x为最小值）；将x压入栈stackMIn中；
        if(stackMin.isEmpty() ||x <= stackMin.peek()) stackMin.push(x);
    }

    public void pop() {
    //stack.pop()实现了出栈操作；
    //stackMin的栈顶元素 == stack的栈顶元素，说明最小值是最后进栈的，也需要出栈；
        if(stack.pop().equals(stackMin.peek())) stackMin.pop();
    }

    public int top() {
        return stack.peek();
    }

    public int min() {
        return stackMin.peek();
    }
}

复杂度

• 时间复杂度 O(1)： push(), pop(), top(), min() 四个函数的时间复杂度均为常数级别。
• 空间复杂度 O(N) ： 当共有 N 个待入栈元素时，辅助栈 B 最差情况下存储 N个元素，使用 O(N) 额外空间。

044-翻转单词顺序列(栈)

题目描述

题解

代码

复杂度

064-滑动窗口的最大值(双端队列)

题目描述

题解

代码

复杂度

Heap

029-最小的K个数

题目描述

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。

示例1

输入

[4,5,1,6,2,7,3,8],4

返回值

[1,2,3,4]

题解

法一：大根堆(前 K 小) / 小根堆（前 K 大),Java中有现成的 PriorityQueue.

• 默认是小根堆，实现大根堆需要重写一下比较器。
  
  PriorityQueue<Integer> queue = new PriorityQueue<>((o1,o2) -> o2-o1);

代码

import java.util.ArrayList;
import java.util.PriorityQueue;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
      if(input.length < k || k < 1) return new ArrayList<>();

      //默认是小根堆，实现大根堆需要重写一下比较器
      PriorityQueue<Integer> queue = new PriorityQueue<>((o1,o2) -> o2-o1);

      //遍历数组
      for(int num : input){
          //近小顶堆填满
          if(queue.size() < k){
              queue.add(num);
          }

            //小顶堆的堆顶为最大值，若遍历的数小于堆顶，将堆顶元素替换
          if(queue.size() >= k && queue.peek() > num){
          queue.poll();
          queue.add(num);
        }
      }

      return new ArrayList<>(queue);
    }
}

复杂度

• 时间复杂度： O(NlogK)
• 空间复杂度： O(K)

Hash Table

034-第一个只出现一次的字符

题目描述

题解

代码

复杂度

图

065-矩阵中的路径(BFS)

题目描述

题解

代码

复杂度

066-机器人的运动范围(DFS)

题目描述

题解

代码

复杂度