Question

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

A={1,3,5,7,6,4,8}
B = {3 5 7 8 8 8 -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;
}

任何人都可以提出o（nlogn）解决方案。

Answer 1

我在O（N）

中做到了

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);
    }
}

Answer 2

创建一个名为c[]的空数组。

从a[]结尾处开始向后工作。

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

删除c[]中小于b[i]的所有内容。

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

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

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

从最后开始，A [i] = 8，C = {}
第一次迭代有点奇怪对于大于8的第一个值，C的二进制搜索没有任何结果，因此B [i] = -1
您不必从C中删除任何内容，因为它是空的，但由于-1，您不得不将其清空。
将A [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}
将A [i] = 5附加到C的开头，因此C = {5,7,8}

现在A [i] = 3，C = {5,7,8}
对于大于3的第一个值，C的二进制搜索给出5，因此B [i] = 5
从C中删除少于5的所有内容，留下C = {5,7,8}
将A [i] = 3附加到C的开头，因此C = {3,5,7,8}

现在A [i] = 1，C = {3,5,7,8}
对于大于1的第一个值，C的二进制搜索给出3，因此B [i] = 3

完成

Answer 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;
}

数组中的下一个较大数字

3 个答案: