Java 练习 1.最小栈 2.发奖金问题 3.删除链表的倒数第 N 个结点

最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

• push(x) —— 将元素 x 推入栈中。
• pop() —— 删除栈顶的元素。
• top() —— 获取栈顶元素。
• getMin() —— 检索栈中的最小元素。

示例:

输入：

["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

输出：

[null,null,null,null,-3,null,0,-2]

解释：

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

提示：

pop、top 和 getMin 操作总是在 非空栈 上调用。

---

class MinStack {
    Stack<Integer> data_stack;
    Stack<Integer> min_stack;
    /** initialize your data structure here. */
    public MinStack() {
        data_stack = new Stack<Integer>();
        min_stack = new Stack<Integer>();
    }
    public void push(int x) {
        data_stack.push(x);
        if (min_stack.isEmpty()) {
            min_stack.push(x);
        } else {
            if (x <= min_stack.peek()) {
                x = min_stack.peek();
            }
            min_stack.push(x);
        }
    }
    public void pop() {
        data_stack.pop();
        min_stack.pop();
    }
    public int top() {
        return data_stack.peek();
    }
    public int getMin() {
        return min_stack.peek();
    }
}
/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

---

发奖金问题

过年了，村里要庆祝。村长说，村里有一笔钱作为奖金，让每个人写一个纸条上来，谁写的数目与奖金最接近，就算猜中，这笔奖金就归谁，如果多人猜中，则平分。编写程序，算算都有哪些人得到奖金？多少？

import java.util.Collections;
import java.util.Comparator;
import java.util.Arrays;

class Q707984 {
    public static void main(String[] args) {
        final int award = 100;
        String[] people = {"a", "b", "c", "d", "e", "f", "g", "h"};
        final Integer[] guess = {75, 70, 80, 120, 100, 110, 100, 45};
        Integer[] ordered = new Integer[people.length];
        for (int i = 0; i < ordered.length; i++)
            ordered[i] = i;
        Arrays.sort(ordered, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                int x = guess[a] - award > 0 ? guess[a] - award : award - guess[a];
                int y = guess[b] - award > 0 ? guess[b] - award : award - guess[b];
                return x - y;
            }
        });
        int maxp = 0;
        int i = 0;
        while (guess[ordered[i++]] == award)
            maxp++;
        if (maxp <= 1)
            System.out.println(people[ordered[0]] + "一人得奖" + award + "元。");
        else {
            for (i = 0; i < maxp; i++)
                System.out.print(people[ordered[i]] + " ");
            System.out.println("共同得奖" + award / (float) (maxp) + "元。");
        }
    }
}

---

删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

进阶：你能尝试使用一趟扫描实现吗？

示例 1：

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

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

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

提示：

链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

public class ListNode {
    int val;
    ListNode next;
    ListNode() {
    }
    ListNode(int val) {
        this.val = val;
    }
    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode v = new ListNode(0, head);
        ListNode handle = v;
        List<ListNode> index = new ArrayList<>();
        while (v != null) {
            index.add(v);
            v = v.next;
        }
        int pre = index.size() - n - 1;
        int next = index.size() - n + 1;
        index.get(pre).next = next >= 0 && next < index.size() ? index.get(next) : null;
        return handle.next;
    }
}

---