Java 下一个较大元素的时间复杂性

Java 下一个较大元素的时间复杂性,java,performance,big-o,Java,Performance,Big O,我已经解决了关于Geeksforgeks问题的下一个更大元素问题。我很困惑地发现以下问题的时间复杂性(大O)。 如果有人能在这方面帮助我,那将是非常有帮助的 问题: 给定一个数组,为每个元素打印下一个较大元素(NGE)。元素x的下一个较大元素是数组中x右侧的第一个较大元素。没有较大元素的元素,考虑下一个更大的元素为-1。< /P> 示例: a) 对于任何数组,最右边的元素总是将下一个较大的元素作为-1 b) 对于按降序排序的数组,所有元素的下一个较大元素为-1 如何找到这个问题的时间复杂性

我已经解决了关于Geeksforgeks问题的下一个更大元素问题。我很困惑地发现以下问题的时间复杂性(大O)。 如果有人能在这方面帮助我,那将是非常有帮助的

问题: 给定一个数组,为每个元素打印下一个较大元素(NGE)。元素x的下一个较大元素是数组中x右侧的第一个较大元素。没有较大元素的元素,考虑下一个更大的元素为-1。< /P> 示例:

a) 对于任何数组,最右边的元素总是将下一个较大的元素作为-1

b) 对于按降序排序的数组,所有元素的下一个较大元素为-1

  • 如何找到这个问题的时间复杂性

  • 这是解决这个问题的可接受的方法吗

        int[] array = {20,10,5,3};
    
        int len =array.length;
        int[] temp = new int[len];
    
        int j=0;
        int i=j;
        while(j<len-1){
            ++i;
            if(i>=len){
                System.out.println(array[j]+"----> -1");
                j++; i=j;
                continue;
            }
            if(array[j]<array[i]){
                System.out.println(array[j]+"----> "+array[i]);
                j++; i=j;
            }
        }
        System.out.println(array[j]+"----> -1");
    
    int[]数组={20,10,5,3};
    int len=array.length;
    int[]临时=新的int[len];
    int j=0;
    int i=j;
    while(j=len){
    System.out.println(数组[j]+“--->-1”);
    j++;i=j;
    继续;
    }
    
    如果(array[j]由于使用的是
    continue
    ,您在确定算法的复杂性时遇到困难,这会给您的推理增加不必要的困难

    重写为以下内容(不使用
    中断
    继续
    ):

    公共无效测试(){
    int[]数组={10,20,3,5};
    int len=array.length;
    对于(int j=0;j”+nge);
    }
    System.out.println(数组[len-1]+“--->-1”);
    }
    

    现在很清楚,这是
    O(n lg n)
    ,因为外部循环迭代到
    n
    ,内部循环迭代到
    n-j

    您很难确定算法的复杂性,因为您正在使用
    continue
    ,这给您的推理增加了不必要的困难

    重写为以下内容(不使用
    中断
    继续
    ):

    公共无效测试(){
    int[]数组={10,20,3,5};
    int len=array.length;
    对于(int j=0;j”+nge);
    }
    System.out.println(数组[len-1]+“--->-1”);
    }
    

    现在很清楚,这是
    O(n lg n)
    因为外部循环迭代到
    n
    ,内部循环迭代到
    n-j

    谢谢你的时间。所以你的意思是说,两种方法的复杂度相同?如果我错了,请纠正我。@Sreekrishnan-我是说,如果算法实现正确,那么算法就具有规定的复杂度。我们都有正确地实现了算法,但您的实现很难推理,因为您使用了一个
    continue
    来实现内部循环。我的算法更清楚地显示为两个循环,一个循环在另一个循环中。您的算法执行两个迭代(都是
    j
    i
    )在一个循环中。我明白你的意思,但是在这两种方法上的性能改进如何。如前所述,是否有类似于内循环的方法比使用continue和break更好?@Sreekrishnan-这两种方法的性能实际上是相同的。在某些机器上可能会有几纳秒的差异,但本质上没有区别nce。我想说的非常重要的一点是,除了算法固有的复杂性之外,你无法提高算法的性能。谢谢你的时间。你的意思是说,两种方法的复杂性相同?如果我错了,请纠正我。@Sreekrishnan-我是说,如果算法正确实现,那么算法就具有相同的复杂性声明的复杂性。我们都正确地实现了算法,但您的实现很难推理,因为您使用了
    continue
    来实现内部循环。我的算法更清楚地显示为两个循环,一个在另一个内部。您的算法执行两个迭代(属于
    j
    i
    )在一个循环中。我明白你的意思,但是在这两种方法上的性能改进如何。如前所述,是否有类似于内循环的方法比使用continue和break更好?@Sreekrishnan-这两种方法的性能实际上是相同的。在某些机器上可能会有几纳秒的差异,但本质上没有区别我想说的非常重要的一点是,除了算法的内在复杂性之外,你无法提高算法的性能。
    public void test() {
        int[] array = {10, 20, 3, 5};
    
        int len = array.length;
    
        for (int j = 0; j < len - 1; j++) {
            int nge = -1;
            for (int i = j + 1; i < len && nge < 0; i++) {
                if (array[j] < array[i]) {
                    nge = array[i];
                }
            }
            System.out.println(array[j] + "----> " + nge);
        }
        System.out.println(array[len-1] + "----> -1");
    }