栈---函数的独占时间

1. 题目
   给出一个非抢占单线程CPU的 n 个函数运行日志，找到函数的独占时间。
   每个函数都有一个唯一的 Id，从 0 到 n-1，函数可能会递归调用或者被其他函数调用。
   日志是具有以下格式的字符串：function_id：start_or_end：timestamp。例如：“0:start:0” 表示函数 0 从 0 时刻开始运行。“0?0” 表示函数 0 在 0 时刻结束。
   函数的独占时间定义是在该方法中花费的时间，调用其他函数花费的时间不算该函数的独占时间。你需要根据函数的 Id 有序地返回每个函数的独占时间。
2. 示例

输入:
n = 2
logs = 
["0:start:0",
 "1:start:2",
 "1:end:5",
 "0:end:6"]
输出:[3, 4]
说明：
函数 0 在时刻 0 开始，在执行了  2个时间单位结束于时刻 1。
现在函数 0 调用函数 1，函数 1 在时刻 2 开始，执行 4 个时间单位后结束于时刻 5。
函数 0 再次在时刻 6 开始执行，并在时刻 6 结束运行，从而执行了 1 个时间单位。
所以函数 0 总共的执行了 2 +1 =3 个时间单位，函数 1 总共执行了 4 个时间单位。

3. 说明
   a.输入的日志会根据时间戳排序，而不是根据日志Id排序。
   b.你的输出会根据函数Id排序，也就意味着你的输出数组中序号为 0 的元素相当于函数 0 的执行时间。
   c.两个函数不会在同时开始或结束。
   d.函数允许被递归调用，直到运行结束。
   e.1 <= n <= 100
4. 代码实现
   数据结构：栈；
   思路：一直都是栈顶元素占用CPU。当碰到start入栈，end出栈。中间涉及到CPU切换，即当栈顶元素改变的时候就是CPU切换的时候。
   栈顶元素改变分为两种情形：当有新元素要入栈，（即CPU被抢占），需要先将当前栈顶元素的speedTime时间加上新元素入栈之前的时间；当有元素出栈，CPU执行权切换到下一个栈顶元素，这时要修改栈顶元素的startTime，置为上一个元素的endTime+1。

import java.util.List;
import java.util.Stack;

public class Solution {
    public int[] exclusiveTime(int n, List<String> logs) {
        int[] times = new int[n];
        Stack<Element> stack = new Stack();
        for (int i = 0; i < logs.size(); i++) {
            String curr[] = logs.get(i).split(":");
            if (curr[1].equals("start")) {
                Element currElement = new Element();
                currElement.id = Integer.parseInt(curr[0]);
                currElement.startTime = Integer.parseInt(curr[2]);
                currElement.speedTime = 0;
                //栈顶元素CPU被抢占
                if (!stack.empty()) {
                    Element top = stack.pop();
                    top.speedTime += currElement.startTime - top.startTime;
                    stack.push(top);
                }
                stack.push(currElement);
            } else if(curr[1].equals("end")){
                Element popElement = stack.pop();
                int endTime = Integer.parseInt(curr[2]);
                popElement.speedTime += endTime - popElement.startTime+1;
                //考虑递归调用
                times[popElement.id]+=popElement.speedTime;
                //下一个栈顶元素重新恢复执行
                if (!stack.empty()) {
                    Element top = stack.pop();
                    top.startTime = endTime+1;
                    stack.push(top);
                }
            }
        }
        return times;
    }

    class Element {
        int id;
        int speedTime;
        int startTime;
    }
}