Java 查找数组中连续整数的第二大和

有人能提供并解释这个问题的解决方案吗

我有一个整数数组

int[] arr = {1,6,2,3,8};

我想找到数组中连续整数的第二大和，并显示元素对，其和产生第二大数

例如，从上面的数组中，连续整数的和是

• 1+6=7
• 6+2=8
• 2+3=5
• 3+8=11

程序的输出是

8 by elements 6,2

这个问题的条件是

必须在单个循环中完成

不能使用新数组

不能对给定数组进行排序

不能使用集合框架

类解决方案{
公共静态void main（字符串[]args）引发IOException{
long max=long.MIN\u值+1，secondMax=long.MIN\u值；
int positionMax=-1，positionSecondMax=-1；
int[]arr={1,6,2,3,8}；
对于（int i=0；i最大值）{
secondMax=max；
positionSecondMax=positionMax；
max=（长）arr[i]+（长）arr[i+1]；
位置max=i；
}
否则如果（arr[i]+arr[i+1]secondMax）{
secondMax=（长）arr[i]+（长）arr[i+1]；
位置最大值=i；
}
}
系统输出打印项次（secondMax+“按元素”+arr[positionSecondMax]+“，“+arr[positionSecondMax+1]）；
}
}

遍历数组的每一个连续对，跟踪最高连续和的位置和内容，以及第二高连续和的位置和内容，并在其获得更高值时进行更新

您需要使用

long

来存储连续的总和，因为如果使用

int

来存储总和，则添加两个

int

可能会使值溢出

public class SecondLargest {
    public static int findSecondLargestConsecutiveSum( final int[] array ){
        if ( array == null )
          throw new IllegalArgumentException( "Cannot find consecutive sum in a null array" );
        if ( array.length < 3 )
          return -1;

        long largest         = Long.MIN_VALUE;
        long secondLargest   = Long.MIN_VALUE;
        int largestPos       = -1;
        int secondLargestPos = -1;
        long sum;
        for ( int i = 0; i < array.length - 1; ++i )
        {
            sum = array[i] + array[i+1];
            if ( sum > largest ) {
                secondLargest = largest;
                secondLargestPos = largestPos; 
                largest = sum;
                largestPos = i;
            }
            else if ( sum < largest && sum > secondLargest ){
                secondLargest = sum;
                secondLargestPos = i;
            }
        }
        return secondLargestPos;
    }

    public static String formatSecondLargest( final int[] array ){
        final int pos = findSecondLargestConsecutiveSum( array );
        if ( pos == -1 )
            return "Array does not have a second largest consecutive sum.";

        return String.format( "%d by elements %d,%d at position %d", (long) array[pos] + (long) array[pos+1], array[pos], array[pos+1], pos );
    }

    public static void main( final String[] args ){
        System.out.println(formatSecondLargest( new int[]{ 1,6,2,3,8 } ) );
        System.out.println(formatSecondLargest( new int[]{ 1,6,2,3,8,3 } ) );
        System.out.println(formatSecondLargest( new int[]{ Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE } ) );
        System.out.println(formatSecondLargest( new int[]{ Integer.MIN_VALUE+1, Integer.MIN_VALUE, Integer.MIN_VALUE+2 } ) );
    }
}

公共类添加{
公共整型左操作数，右操作数；
公共整数和；
公共加法（整数左、整数右）{
总和=（this.leftOperator=左）+（this.righOperator=右）；
}
公共静态加法get（int[]数组）{
//初始化前两个内存
加法max=null，secMax=null；
对于（int i=0；i

这里有一个尝试。一个循环，存储求和操作数以及最高和第二高和的求和

    int[] arr = {1,6,2,3,8};

    int highestFirstOperand = -1;
    int highestSecondOperand = -1;
    int secondHighestFirstOperand = -1;
    int secondHighestSecondOperand = -1;
    int highestSum = -1;
    int secondHighestSum = -1;
    for (int i=0; i<arr.length; i++) {
        if (i<arr.length-1) {
            int thisSum = arr[i] + arr[i + 1];
            if (thisSum > highestSum) {
                secondHighestSum = highestSum;
                secondHighestFirstOperand = highestFirstOperand;
                secondHighestSecondOperand = highestSecondOperand;
                highestSum = thisSum;
                highestFirstOperand = arr[i];
                highestSecondOperand = arr[i+1];
            } else if (thisSum > secondHighestSum) {
                secondHighestSum = thisSum;
                secondHighestFirstOperand = arr[i];
                secondHighestSecondOperand = arr[i + 1];
            }
        }
    }
    System.out.println(secondHighestSum + " by elements " + secondHighestFirstOperand + "," + secondHighestSecondOperand);

int[]arr={1,6,2,3,8}；
int highestFirstOperand=-1；
int highestsecond操作数=-1；
int secondHighestFirstOperand=-1；
int secondHighestSecondOperand=-1；
int highestSum=-1；
int secondHighestSum=-1；
for（int i=0；i次高总和）{
次高总和=此总和；
次高第一个操作数=arr[i]；
secondHighestSecondOperand=arr[i+1]；
}
}
}
System.out.println（secondHighestSum+“by elements”+secondHighestFirstOperand+“，“+secondHighestSecondOperand”）；

任何人都可以提供并解释此问题的解决方案，但不能说您涵盖了解释部分。添加了解释-该算法很简单，因为它只是在列表中迭代跟踪最大值和第二最大值的位置以及它们的值，当发现更高的值时更新它们。您必须在每个阶段存储变量中max和secondmax的位置，以便能够在末尾显示元素。为什么使用计数器变量？对于

int[]{Integer.MIN_值，Integer.MIN_值+1，Integer.MIN_值+2}不起作用

@MT0您不能使用该参数，因为没有给出数字限制。我们将最大值设置为比给定约束中可能的最小值小1。给出了数字约束-它是一个

int

数组，因此介于

Integer.MIN\u值
和
Integer.max\u值
之间，连续和可以介于
2*Integer.MIN\u值
和之间
2*Integer.MAX_值
（将溢出
int
）。
8 by elements 6,2 at position 1
8 by elements 6,2 at position 1
Array does not have a second largest consecutive sum.
-4294967295 by elements -2147483647,-2147483648 at position 0

public class Addition{
  public int leftOperand, rightOperand;
  public int sum;
  public Addition(int left, int right){
    sum = (this.leftOperand = left) + (this.rightOperand = right);
  }



  public static Addition get(int[] array){
    // initialize top two memory
    Addition max = null, secMax = null;
    for(int i = 0; i < array.length - 1; $i++){
      Addition add = new Addition(array[i], array[i + 1]);
      if(max == null){
        max = secMax = add; // initialize them for the first time
        continue;
      }
      if(secMax.sum < add.sum){
        secMax = add; // displaces second max
        if(max.sum < add.sum){ // add is already second max. This doesn't need to be outside the former if block.
          secMax = max;
          max = add;
        }
      }
    }
    return secMax;
  }
}

    int[] arr = {1,6,2,3,8};

    int highestFirstOperand = -1;
    int highestSecondOperand = -1;
    int secondHighestFirstOperand = -1;
    int secondHighestSecondOperand = -1;
    int highestSum = -1;
    int secondHighestSum = -1;
    for (int i=0; i<arr.length; i++) {
        if (i<arr.length-1) {
            int thisSum = arr[i] + arr[i + 1];
            if (thisSum > highestSum) {
                secondHighestSum = highestSum;
                secondHighestFirstOperand = highestFirstOperand;
                secondHighestSecondOperand = highestSecondOperand;
                highestSum = thisSum;
                highestFirstOperand = arr[i];
                highestSecondOperand = arr[i+1];
            } else if (thisSum > secondHighestSum) {
                secondHighestSum = thisSum;
                secondHighestFirstOperand = arr[i];
                secondHighestSecondOperand = arr[i + 1];
            }
        }
    }
    System.out.println(secondHighestSum + " by elements " + secondHighestFirstOperand + "," + secondHighestSecondOperand);