C++ 数组中的下一个较大数字

给您一个由n个元素组成的未排序数组A，现在为其构造一个数组B B[i]=A[j]，其中j是最小数，使得A[j]>A[i]和j>i 如果这样的j不存在，B[i]=-1 例如：

我的解决方案

#include<iostream>
using namespace std;
int main()
{
    int a[7]={9,3,5,2,6,4,8},b[7];
    int i,j,largest = -1;
    for(i=0;i<7;i++)
    {
        j=i+1;
        while(j<7)
        {
         if(a[j]>a[i])
         {
             largest=a[j];
             break;
         }
         j++;
        }
        if(j == 7)
        largest = -1;
        b[i]= largest;
    }
    for(j=0;j<7;j++)
    cout<<b[j]<<endl;
    return 0;
}

#包括
使用名称空间std；
int main（）
{
inta[7]={9,3,5,2,6,4,8}，b[7]；
int i，j，最大值=-1；
对于（i=0；i创建一个名为
c[]
的空数组

从
a[]
的末尾开始，然后向后操作

在
c[]
中进行二进制搜索，查找第一个大于
a[i]
的值。如果找不到，请将其放入
b[i]
，或a-1

将小于
b[i]
的所有内容放入
c[]
中

将
a[i]
附加到
c[]
的开头

c[]
将始终进行排序，允许二进制搜索


例如，对于样本A={1,3,5,7,6,4,8}

从末尾开始，A[i]=8，C={}

第一次迭代有点奇怪。

对于大于8的第一个值，对C进行二进制搜索时不会给出任何结果，因此B[i]=-1

您不必因为C是空的而从C中删除任何内容，但由于-1，您无论如何都必须清空它。

将[i]=8追加到C的开头，因此C={8}

现在A[i]=4，C={8}

对于大于4的第一个值，对C进行二进制搜索得到8，因此B[i]=8

从C中删除小于8的所有内容，这仍然会留下C={8}

将A[i]=4附加到C的开头，因此C={4,8}

现在A[i]=6，C={4,8}

对于大于6的第一个值，对C进行二进制搜索得到8，因此B[i]=8

从C中删除小于8的所有内容，这将留下C={8}

将A[i]=6附加到C的开头，因此C={6,8}

现在A[i]=7，C={6,8}

对于大于7的第一个值，对C进行二进制搜索得到8，因此B[i]=8

从C中删除小于8的所有内容，这将留下C={8}

将A[i]=7附加到C的开头，因此C={7,8}

现在A[i]=5，C={7,8}

对于大于5的第一个值，对C进行二进制搜索得到7，因此B[i]=7

从C中删除小于7的所有内容，这将留下C={7,8}

在C的开头加上A[i]=5，这样C={5,7,8}

现在A[i]=3，C={5,7,8}

对于大于3的第一个值，对C进行二进制搜索得到5，因此B[i]=5

从C中删除小于5的所有内容，这将留下C={5,7,8}

在C的开头加上A[i]=3，这样C={3,5,7,8}

现在A[i]=1，C={3,5,7,8}

对于大于1的第一个值，对C进行二进制搜索得到3，因此B[i]=3

我认为二进制搜索在这里是一个麻烦。尽管有嵌套循环，但它只执行n项比较和n项拷贝

int _tmain()
{
    int a[]=/*{1,3,5,7,6,4,8};*/{9,3,5,2,6,4,8};
    int b[_countof(a)];


    int prevIdx = 0;
    for(int i = 0; i < _countof(a); i++)
    {
        if(a[i] > a[prevIdx])
        {
            for(int j = prevIdx; j < i; j++)
                b[j] = a[i];

            prevIdx = i;
        }
    }

    for(int j = prevIdx; j < _countof(b); j++)
        b[j] = -1;

    for(int j=0;j<7;j++)
        std::cout<<b[j]<<std::endl;

    return 0;
}

int\u tmain（）
{
int a[]=/*{1,3,5,7,6,4,8}；*/{9,3,5,2,6,4,8}；
int b[_countof（a）]；
int-prevIdx=0；
对于（int i=0；i<_（a）；i++）
{
如果（a[i]>a[prevIdx]）
{
对于（int j=prevIdx；j
import java.util.Stack；
公开课考试{
公共静态void upateArray（int[]a）{
堆栈=新堆栈（）；
int len=a.长度；
int cur=0；
while（cur
您自己的解决方案的大O是什么？为什么？您考虑过如何获得O（NloN）？我只是想知道二进制搜索是否可以以某种方式应用于确定位置。2件事：1，示例输出错误-根据问题的描述，它应该是
{3，4，6，8，8，8，-1}
.2，要将其保存到O（N Log N）的唯一方法是首先对数组进行排序（然后你可以对结果数组使用二进制搜索。@Zac，它在寻找最小的j，即值较大的最小索引，而不是最小值。@Karl:啊，我误读了它。第二点仍然成立，-1是什么意思？我对问题的分析或这个特定解决方案的运行时复杂性是错误的吗？首先，这是错误的打印所有-1作为答案，而答案应该是-1、5、6、6、8、-1。此外，我非常确定最坏情况下的运行时复杂性是O（n^2），即使平均情况可能更好。如果不是这样，您将能够重构出内部循环。@Karl我知道我误解了需求的地方-这无助于解决原始问题。但我不同意您的复杂性分析。内部循环的限制方式确保了一个循环中只有n个赋值对b来说，内部循环可以很容易地分解出来，使其成为一个两次通过的算法，尽管这样做不太优雅。@prp，请参阅我的编辑。鉴于这是家庭作业，我将把实际代码留给读者作为练习：-）
int _tmain()
{
    int a[]=/*{1,3,5,7,6,4,8};*/{9,3,5,2,6,4,8};
    int b[_countof(a)];


    int prevIdx = 0;
    for(int i = 0; i < _countof(a); i++)
    {
        if(a[i] > a[prevIdx])
        {
            for(int j = prevIdx; j < i; j++)
                b[j] = a[i];

            prevIdx = i;
        }
    }

    for(int j = prevIdx; j < _countof(b); j++)
        b[j] = -1;

    for(int j=0;j<7;j++)
        std::cout<<b[j]<<std::endl;

    return 0;
}

import java.util.Stack;

public class Test {

    public static void upateArray(int[] a){
        Stack<Integer> stack = new Stack<Integer>();
        int len = a.length;
        int cur = 0;
        while(cur < len){
            while(!stack.isEmpty() && a[stack.peek()] < a[cur]){
                a[stack.pop()] = a[cur];
            }
            stack.push(cur);
            cur++;
        }
    }

    public static void main (String args[]){
        int a[] = {3,2,5,11,4,11,13,8,6,20,10};
        upateArray(a);
        for(int i : a)
            System.out.print(" "+i);
    }
}