如何在數組中找到最大的三角洲？

Question

可以說我試圖效仿一組股票價格。這些股票價格都在一個陣列中。三角洲是這些價格之間的差額。我正在尋找最大增量並將其返回給數組。當我試圖在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; 
    } 
} 

什麼我可能做錯了嗎？

Answer 1

變化

int[] largestDelta = {0}; 

到

int largestDelta = stocks[0]; 

或

int largestDelta = 0; 

還記得有關更改返回類型。

Answer 2

問題是你試圖比較一個int和一個數組。這當然是一個錯誤：delta > largestDelta。

另一個錯誤是，你要指定一個int到一個數組。這條線也是錯誤的：largestDelta = stocks[i];

你有最大的三角洲更改爲int，就像這樣：

int largestDelta = 0; 

這樣做了以後，你就可以比較delta和largestDelta，還可以指派stocks[i]至largestDelta

希望這有助於！

Answer 3

你是比較一個int，delta，有一個int []，largestDelta。也許，你應該簡單地說int largestDelta = 0;和定義public static int findMaximumProfit(int[] stocks)？ 如果你正在尋找所有可能的股票之間的所有增量的最大值，你需要做一個雙循環：

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

Answer 4

考慮保持您三角洲的軌道，讓你知道他們有多少人，並可選擇做一些稍後進行額外的操作。另外，利用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; 
    } 
} 

會給你的輸出：

Best amount of profit is 
Profit : 5, delta=4 
Profit : 10, delta=3 
Profit : 1, delta=1 
Profit : 6, delta=1 
Profit : 7, delta=1 
Profit : 6, delta=0 
Profit : 7, delta=0 
Profit : 10, delta=0 

如果排序是你原來的數組中重要的是，你可能想換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; 
    } 
} 

，輸出：

Best amount of profit is 
Profit : 5, delta=4, originalIndex=5 
Profit : 10, delta=3, originalIndex=4 
Profit : 1, delta=1, originalIndex=0 
Profit : 6, delta=1, originalIndex=2 
Profit : 7, delta=1, originalIndex=1 
Profit : 6, delta=0, originalIndex=6 
Profit : 7, delta=0, originalIndex=3 
Profit : 10, delta=0, originalIndex=7