Algorithm 按开始时间对完成的请求进行排序

给定到达未知时间且id为的请求： 1.StartRequest（内部id） 2.EndRequest（内部id）

我需要返回已完成请求的ID，其总时间（endTime startTime）按开始时间排序

请注意，如果之前的请求尚未完成，则即使当前请求已完成，也不会返回该请求

我试过天真的方式： 在开始请求时，我向列表中添加请求，在结束请求时，我检查从列表开始到第一个未完成的请求是否存在，并返回它们

---

有没有更有效的方法？在EndRequest上返回结果是最好的方法吗？

使用您最喜欢/使用的语言使用以下过程：

public class StartEndRequest {
private static void swap(int [] starts, int [] ends, int i, int j) {
    int temp = starts[i];
    int temp1 = ends[i];

    starts[i] = starts[j];
    ends[i] = ends[j];

    starts[j] = temp;
    ends[j] = temp1;
}
// selection sort ..
private static void sortByProcessTime(int [] starts, int [] ends) {
    for(int i=0; i<starts.length-1; i++) {
        int min = i;
        for(int j=i+1; j<starts.length; j++) {
            // swap according to execution time..
            if((ends[j] - starts[j]) > (ends[i] - starts[i]))
                min = j;
        }

        swap(starts, ends, i, min);
    }
}
private static ArrayList<ArrayList<Integer>> getFinishedProcess(int [] prevProcess, int [] starts, int [] ends){
    ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();

    for(int i=0; i<prevProcess.length; i++) {
        // add the first operation, it has no prev. operation..
        if(i == 0) {
            ArrayList<Integer> temp = new ArrayList<>();
            temp.add(starts[i]);
            temp.add(ends[i]);

            list.add(temp);
        }
        if(prevProcess[i] != -1) {
            ArrayList<Integer> temp = new ArrayList<>();
            temp.add(starts[i]);
            temp.add(ends[i]);

            list.add(temp);
        }
    }
    return list;
}
private static void blockUnfinishedProcess(int [] preProcesses, int [] starts, int [] ends) {
    for(int i=1; i<preProcesses.length; i++) {
        if(ends[i] == -1) {
            preProcesses[i] = -1;
        }
    }
}
public static void main(String[] args) {
    // use an auxiliary space to point prev. operations..
    int [] prevProcess = {-1, 0, 0, 0, 0, 0};
    int [] startReq = {2, 3, 1, 4, 6, 5};
    // i am using -1 to indicate unfinished jobs..
    int [] endReq = {7, 4, 3, -1, 8, -1};

    // sort according to execution time..
    sortByProcessTime(startReq, endReq);

    // block those operation whose prev was not finished ..
    blockUnfinishedProcess(prevProcess, startReq, endReq);

    //
    for(int i=0; i<startReq.length; i++) {
        System.out.println(startReq[i]+" -- "+endReq[i]);
    }

    // add only those operation, whose prev also executed successfully.. 
    System.out.println(getFinishedProcess(prevProcess, startReq, endReq));
}

公共类启动请求{
私有静态无效交换（int[]开始，int[]结束，int i，int j）{
int temp=启动[i]；
int temp1=结束[i]；
开始[i]=开始[j]；
结束[i]=结束[j]；
开始[j]=温度；
结束[j]=temp1；
}
//选择排序。。
私有静态void sortByProcessTime（int[]开始，int[]结束）{
对于（inti=0；iIt是一个非常经典的排序，您所要做的就是实现一个看起来像
boolean更小的函数（object1，object2）
。这类函数通常称为“comparator”。完成后，您可以使用自己选择的排序算法实现排序，替换符号
，因为您可以在到达时保存请求。挑战是在完成后返回它们。例如，如果您收到请求：如果OP不懂Java，他就很难从你的代码中得到任何意义。因为我只使用编程的基本逻辑，我不认为这对OP来说很难明白了！以后我还会记得的！谢谢！