Java 如何找到阵列中的最大增量？_Java_Arrays

Java 如何找到阵列中的最大增量？

java arrays

Java 如何找到阵列中的最大增量？,java,arrays,Java,Arrays,让我们假设我正试图模仿一组股票价格。每个股票价格都是一个数组。delta是这些价格之间的差异。我正在寻找一个数组，找到最大增量并将其返回到数组。当我试图在Eclipse中实现这一点时，这两行代码出现以下错误： if (delta > largestDelta) { largestDelta = stocks[i]; } “未为参数类型int，int[]定义运算符>” “类型不匹配：无法从int转换为int[]” 这是我的全部代码： public class Stocks {

让我们假设我正试图模仿一组股票价格。每个股票价格都是一个数组。delta是这些价格之间的差异。我正在寻找一个数组，找到最大增量并将其返回到数组。当我试图在Eclipse中实现这一点时，这两行代码出现以下错误：

if (delta > largestDelta) {
   largestDelta = stocks[i];
}

“未为参数类型int，int[]定义运算符>”
“类型不匹配：无法从int转换为int[]”

这是我的全部代码：

public class Stocks {
    static int[] stocks = { 1, 7, 6, 7, 10, 5, 6, 10 };

    // delta = sell point - buy point
    // find largest delta

    public static int[] findMaximumProfit(int[] stocks) {

        int delta = 0;
        int[] largestDelta = {0};
        for (int i=0; i < stocks.length; i++) {
            delta = stocks[i+1] - stocks[i]; 
            if (delta > largestDelta) {
                largestDelta = stocks[i];
            }
        }
        return largestDelta;
   }
}

公共类股票{
静态int[]股票={1,7,6,7,10,5,6,10}；
//delta=卖出点-买入点
//寻找最大的三角洲
公共静态int[]FindMaximum盈利（int[]股票）{
int delta=0；
int[]最大增量={0}；
对于（int i=0；i最大增量）{
最大增量=存量[i]；
}
}
返回最大增量；
}
}

我可能做错了什么？

改变

int[] largestDelta = {0};

到

或

还记得更改退货类型。

更改

int[] largestDelta = {0};

到

或

还要记住更改返回类型。

问题是您试图比较int和数组。这当然是一个错误：

delta>largestDelta

另一个错误是将int赋值给数组。此行也是一个错误：

largestDelta=stocks[i]
必须将最大增量更改为int，如下所示：
int largestDelta = 0;

完成此操作后，您将能够比较增量
和最大增量
，并将股票[i]
分配给最大增量

希望这有帮助
 问题是您试图比较int和数组。这当然是一个错误：delta>largestDelta

另一个错误是将int赋值给数组。此行也是一个错误：largestDelta=stocks[i]
必须将最大增量更改为int，如下所示：
int largestDelta = 0;

完成此操作后，您将能够比较增量
和最大增量
，并将股票[i]
分配给最大增量

希望这有帮助
 您正在比较一个int，delta
，和一个int[]，最大的delta
。也许，您应该简单地说int largestDelta=0并定义公共静态int findMaximumProfit（int[]股票）？
如果您正在寻找所有可能库存之间所有增量的最大值，则需要执行双循环：
for (int i=0; i < stocks.length; i++) {
    for (int j=i+1; j < stocks.length; j++) {
        delta = stocks[j] - stocks[i]; 
        if (delta > largestDelta) {
            largestDelta[0] = i;
            largestDelta[1] = j;    
        }
    }
}

for（int i=0；i最大增量）{
最大增量[0]=i；
最大增量[1]=j；
}
}
}
您正在将一个int、增量
与一个int[]、最大增量
进行比较。也许，您应该简单地说int largestDelta=0并定义公共静态int findMaximumProfit（int[]股票）？
如果您正在寻找所有可能库存之间所有增量的最大值，则需要执行双循环：
for (int i=0; i < stocks.length; i++) {
    for (int j=i+1; j < stocks.length; j++) {
        delta = stocks[j] - stocks[i]; 
        if (delta > largestDelta) {
            largestDelta[0] = i;
            largestDelta[1] = j;    
        }
    }
}

for（int i=0；i最大增量）{
最大增量[0]=i；
最大增量[1]=j；
}
}
}
考虑跟踪您的增量，这样您就可以知道它们的数量，并且可以选择在以后执行一些额外的操作。另外，利用Java在订购和包装方面已经提供的功能
例如：
import java.util.*;

class ProfitDelta implements Comparable<ProfitDelta> {
    private int delta;
    private int profit;
    public ProfitDelta(int delta, int profit) { this.delta = delta; this.profit = profit; }
    public int getDelta() { return delta; }
    public int getProfit() { return profit; }
    public int compareTo(ProfitDelta o) {
        return o.delta - this.delta;    
    }
}

class Main {
    static Integer[] stocks = { 1, 7, 6, 7, 10, 5, 6, 10 };

    public static void main(String[] args) {
        System.out.println("Best amount of profit is ");
        for (ProfitDelta profit : getBestProfitAmount(stocks)) {
            System.out.println("Profit : " + profit.getProfit() + ", delta=" + profit.getDelta());
        }
    }

    public static ProfitDelta[] getBestProfitAmount(Integer[] stocks) {
        ProfitDelta[] profits = new ProfitDelta[stocks.length];

        List<Integer> sortedStocks = Arrays.asList(stocks);
        List<ProfitDelta> sortedProfits = Arrays.asList(profits);
        Collections.sort(sortedStocks);

        int delta = 0;
        int stockValue;
        for (int i = 0; i < stocks.length; i++) {
            stockValue = sortedStocks.get(i);
            delta = stockValue - delta;
            sortedProfits.set(i, new ProfitDelta(delta, stockValue));

            delta = stockValue;
        }
        Collections.sort(sortedProfits);
        return profits;
    }
}

如果排序在原始数组中很重要，您可能希望将sortedStocks
包装到另一个类中，该类将保留原始索引值，并将属性originalIndex
添加到ProfitDelta
。或者事件更简单，如下所示：
import java.util.*;

class ProfitDelta implements Comparable<ProfitDelta> {
    private int originalIndex = 0;
    private int delta = 0;
    private int profit;
    public ProfitDelta(int index, int profit) { this.originalIndex = index; this.profit = profit; }
    public int getOriginalIndex() { return originalIndex; }
    public int getDelta() { return delta; }
    public void setDelta(int delta) { this.delta = delta; }
    public int getProfit() { return profit; }
    public int compareTo(ProfitDelta o) { return o.delta - this.delta; }
}

class ProfitComparator implements Comparator<ProfitDelta> {
    @Override public int compare(ProfitDelta o1, ProfitDelta o2) {
        return o1.getProfit() - o2.getProfit();
    }   
}

class Main {
    static int[] stocks = { 1, 7, 6, 7, 10, 5, 6, 10 };

    public static void main(String[] args) {
        System.out.println("Best amount of profit is ");
        for (ProfitDelta profit : getBestProfitAmount(stocks)) {
            System.out.println("Profit : " + profit.getProfit() + 
                ", delta=" + profit.getDelta() +
                ", originalIndex=" + profit.getOriginalIndex());
        }
    }

    public static ProfitDelta[] getBestProfitAmount(int[] stocks) {
        ProfitDelta[] profits = new ProfitDelta[stocks.length];
        int delta = 0;

        List<ProfitDelta> sortedProfits = Arrays.asList(profits);
        for (int i = 0; i < stocks.length; i++) {
            sortedProfits.set(i, new ProfitDelta(i, stocks[i]));
        }
        Collections.sort(sortedProfits, new ProfitComparator());

        for (ProfitDelta profit : profits) {
            profit.setDelta(profit.getProfit() - delta);
            delta = profit.getProfit();
        }
        Collections.sort(sortedProfits);

        return profits;
    }
}

考虑跟踪您的增量，这样您就可以知道它们的大小，并且可以选择在以后执行一些额外的操作。另外，利用Java在订购和包装方面已经提供的功能
例如：
import java.util.*;

class ProfitDelta implements Comparable<ProfitDelta> {
    private int delta;
    private int profit;
    public ProfitDelta(int delta, int profit) { this.delta = delta; this.profit = profit; }
    public int getDelta() { return delta; }
    public int getProfit() { return profit; }
    public int compareTo(ProfitDelta o) {
        return o.delta - this.delta;    
    }
}

class Main {
    static Integer[] stocks = { 1, 7, 6, 7, 10, 5, 6, 10 };

    public static void main(String[] args) {
        System.out.println("Best amount of profit is ");
        for (ProfitDelta profit : getBestProfitAmount(stocks)) {
            System.out.println("Profit : " + profit.getProfit() + ", delta=" + profit.getDelta());
        }
    }

    public static ProfitDelta[] getBestProfitAmount(Integer[] stocks) {
        ProfitDelta[] profits = new ProfitDelta[stocks.length];

        List<Integer> sortedStocks = Arrays.asList(stocks);
        List<ProfitDelta> sortedProfits = Arrays.asList(profits);
        Collections.sort(sortedStocks);

        int delta = 0;
        int stockValue;
        for (int i = 0; i < stocks.length; i++) {
            stockValue = sortedStocks.get(i);
            delta = stockValue - delta;
            sortedProfits.set(i, new ProfitDelta(delta, stockValue));

            delta = stockValue;
        }
        Collections.sort(sortedProfits);
        return profits;
    }
}

如果排序在原始数组中很重要，您可能希望将sortedStocks
包装到另一个类中，该类将保留原始索引值，并将属性originalIndex
添加到ProfitDelta
。或者事件更简单，如下所示：
import java.util.*;

class ProfitDelta implements Comparable<ProfitDelta> {
    private int originalIndex = 0;
    private int delta = 0;
    private int profit;
    public ProfitDelta(int index, int profit) { this.originalIndex = index; this.profit = profit; }
    public int getOriginalIndex() { return originalIndex; }
    public int getDelta() { return delta; }
    public void setDelta(int delta) { this.delta = delta; }
    public int getProfit() { return profit; }
    public int compareTo(ProfitDelta o) { return o.delta - this.delta; }
}

class ProfitComparator implements Comparator<ProfitDelta> {
    @Override public int compare(ProfitDelta o1, ProfitDelta o2) {
        return o1.getProfit() - o2.getProfit();
    }   
}

class Main {
    static int[] stocks = { 1, 7, 6, 7, 10, 5, 6, 10 };

    public static void main(String[] args) {
        System.out.println("Best amount of profit is ");
        for (ProfitDelta profit : getBestProfitAmount(stocks)) {
            System.out.println("Profit : " + profit.getProfit() + 
                ", delta=" + profit.getDelta() +
                ", originalIndex=" + profit.getOriginalIndex());
        }
    }

    public static ProfitDelta[] getBestProfitAmount(int[] stocks) {
        ProfitDelta[] profits = new ProfitDelta[stocks.length];
        int delta = 0;

        List<ProfitDelta> sortedProfits = Arrays.asList(profits);
        for (int i = 0; i < stocks.length; i++) {
            sortedProfits.set(i, new ProfitDelta(i, stocks[i]));
        }
        Collections.sort(sortedProfits, new ProfitComparator());

        for (ProfitDelta profit : profits) {
            profit.setDelta(profit.getProfit() - delta);
            delta = profit.getProfit();
        }
        Collections.sort(sortedProfits);

        return profits;
    }
}

您正在将数组int[]largesteddelta
与和intdelta
进行比较，相反，您应该比较delta>largesteddelta[0]
为什么不1）对数组排序，然后从最后一个元素中减去第一个元素，或者2）迭代数组，跟踪最小和最大元素，然后相互减去它们（稍微快一点）？这听起来像是这个问题的反面：你找到你的问题的答案了吗？或者，答案中有什么不能解决你的问题？你正在比较数组int[]largestDelta
和intdelta
，你应该比较delta>largestDelta[0]
为什么不是1）对数组排序，然后从最后一个元素中减去第一个元素，或者2）迭代数组，跟踪最小元素和最大元素，然后将它们相互减去（稍微快一点）？这听起来像是问题的反面：你找到问题的答案了吗？或者，答案中有什么不能解决你的问题？