1.
//最小栈
class MinStack {
Deque<Integer> stack;
Deque<Integer> minStack;
/** initialize your data structure here. */
public MinStack() {
stack = new LinkedList<Integer>();
minStack = new LinkedList<Integer>();
minStack.push(Integer.MAX_VALUE);
}
public void push(int x) {
stack.push(x);
minStack.push(Math.min(minStack.peek(),x));
}
public void pop() {
stack.pop();
minStack.pop();
}
public int top() {
return stack.peek();
}
public int getMin() {
return minStack.peek();
}
}
2.
//数组中的第K个最大元素
public int findKthLargest(int[] nums, int k) {
Arrays.sort(nums);
int count = 0;
int tmp = Integer.MAX_VALUE;
for (int i = nums.length - 1; i >= 0; i--) {
if (nums[i] < tmp){
tmp = nums[i];
count++;
}else if (nums[i] == tmp){
count++;
}
if (count == k){
return tmp;
}
}
return Integer.MAX_VALUE;
}
3.
//数据流的中位数
class MedianFinder {
private Queue<Integer> left = new PriorityQueue<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
private Queue<Integer> right = new PriorityQueue<>();
/** initialize your data structure here. */
public MedianFinder() {
}
public void addNum(int num) {
if (left.size() == right.size()){
if (left.size() == 0){
left.add(num);
}else if (num <= right.peek()){
left.add(num);
}else {
left.add(right.poll());
right.add(num);
}
}else {
if (num >= left.peek()){
right.add(num);
}else {
right.add(left.poll());
left.add(num);
}
}
}
public double findMedian() {
if (left.size() > right.size()){
return (double)left.peek();
}else {
return (double)(left.peek() + right.peek()) / 2.0;
}
}
}
4.
//有序矩阵中第K小的元素
public int kthSmallest(int[][] matrix, int k) {
Queue<Integer> queue = new PriorityQueue<>();
for (int[] ints : matrix) {
for (int anInt : ints) {
queue.add(anInt);
}
}
for (int i = 0; i < k - 1; i++) {
queue.poll();
}
return queue.peek();
}
5.
//前 K 个高频元素
public int[] topKFrequent(int[] nums, int k) {
HashMap<Integer,Integer> map = new HashMap<>();
for (int num : nums) {
map.put(num,map.getOrDefault(num,0)+1);
}
Queue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return o1[1] - o2[1];
}
});
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
int num = entry.getKey();
int count = entry.getValue();
if (queue.size() == k){
if (count > queue.peek()[1]){
queue.poll();
queue.offer(new int[]{
num,count});
}
}else {
queue.offer(new int[]{
num,count});
}
}
int[] knums = new int[k];
for (int i = 0; i < knums.length; i++) {
knums[i] = queue.poll()[0];
}
return knums;
}
6.
//滑动窗口最大值
public int[] maxSlidingWindow(int[] nums, int k) {
int n = nums.length;
PriorityQueue<int[]> pq = new PriorityQueue<int[]>(new Comparator<int[]>() {
public int compare(int[] pair1, int[] pair2) {
return pair1[0] != pair2[0] ? pair2[0] - pair1[0] : pair2[1] - pair1[1];
}
});
for (int i = 0; i < k; ++i) {
pq.offer(new int[]{
nums[i], i});
}
int[] ans = new int[n - k + 1];
ans[0] = pq.peek()[0];
for (int i = k; i < n; ++i) {
pq.offer(new int[]{
nums[i], i});
while (pq.peek()[1] <= i - k) {
pq.poll();
}
ans[i - k + 1] = pq.peek()[0];
}
return ans;
}
7.
//基本计算器 II
public int calculate(String s) {
Stack<Integer> stack = new Stack<>();
char lastcop = '+';
char[] arr = s.toCharArray();
for (int i = 0; i < arr.length; i++) {
if (arr[i] == ' '){
continue;
}
if (Character.isDigit(arr[i])){
int tempNum = arr[i] - '0';
while ( i+1 < arr.length && Character.isDigit(arr[i+1])){
tempNum = tempNum * 10 + arr[i+1] - '0';
i++;
}
if (lastcop == '+'){
stack.push(tempNum);
}else if (lastcop == '-'){
stack.push(-tempNum);
}else {
stack.push(res(lastcop,stack.pop(),tempNum));
}
}else {
lastcop = arr[i];
}
}
int total = 0;
for (Integer integer : stack) {
total += integer;
}
return total;
}
private int res(char op, int a, int b) {
if (op == '*'){
return a * b;
}else {
return a / b;
}
}
8.
//扁平化嵌套列表迭代器
public class NestedIterator implements Iterator<Integer> {
private List<NestedInteger> list;
private Deque<Integer> stack;
public NestedIterator(List<NestedInteger> nestedList) {
this.list = nestedList;
stack = new ArrayDeque<>();
instance(list);
}
@Override
public Integer next() {
return stack.poll();
}
@Override
public boolean hasNext() {
if (stack.isEmpty()){
return false;
}
return true;
}
private void instance(List<NestedInteger> list){
for (int i = 0; i < list.size(); i++) {
if (list.get(i).isInteger()){
stack.offer(list.get(i).getInteger());
}else {
instance(list.get(i).getList());
}
}
}
}
public interface NestedInteger {
public boolean isInteger();
public Integer getInteger();
public List<NestedInteger> getList();
}
9.
//逆波兰表达式求值
public int evalRPN(String[] tokens) {
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < tokens.length; i++) {
String str = tokens[i];
if (str.length() > 1){
stack.push(Integer.parseInt(str));
}else if (Character.isDigit(str.charAt(0))){
stack.push(Integer.parseInt(str));
}else {
int a = stack.pop();
int b = stack.pop();
if (tokens[i].equals("+")){
stack.push(b+a);
}else if (tokens[i].equals("-")){
stack.push(b-a);
}else if (tokens[i].equals("*")){
stack.push(b*a);
}else {
stack.push(b/a);
}
}
}
return stack.pop();
}