求一个数组求次大值的算法，要求用数组{:soso_e116:}
可以以斐波那契数列为例，或者自己定义一个数组
int[] arr={1,1,2,3,5,8,13,21,34,55};

是不是可以先排序..然后？？

先用Arrays.sort()把数组排序，然后返回最大值的前一个值。
如果要自己算的话，可以用选择或者冒泡排序，只循环两次取出排好的那两个值。
或者定义两个变量max1,max2，在数组里循环比较取出最大的两个值。
int max1,max2;
for(int x;x<arr.length;i++)
{
if(arr[x]>max1&&arr[x]>max2){
     //arr[x]放入max1;
   }else if(arr[x]<max1&&arr[x]>max2){
     //arr[x]放入max2;
   }
}return max2;
补个代码，又看了看应该还是第三种比较快。然后就是如果有几个元素数值相同都是最大值的情况，第三种也能正确取出次大值。

这是我写的，希望对你有帮助，用了一个冒泡排序：
public static int getSendMax(int[] arr){
                for(int x = 0 ; x < arr.length ; x++){
                        for(int y = 0 ; y < arr.length - 1 - x ; y++){
                                if(arr[y] > arr[y+1]){
                                        int temp = arr[y];
                                        arr[y] = arr[y+1];
                                        arr[y+1] = temp;
                                }
                        }
                }
                return arr[arr.length - 2];
        }

这是我想的，，只用一次循环，效率可能会更高点

1. void getSecondMax(){
   
2.                
   
3.              int []arr={5500,78,1000,2000,79,80,-34,-45,-23,30,-29,-3,9,8,-12};
   
4.                  int  max=arr[0];
   
5.                  int  nextmax=arr[1];
   
6.                 for(int i=0;i<arr.length;i++){
   
7.                        
   
8.                         if(max<arr[i]){
   
9.                                 nextmax=max;
   
10.                                 max=arr[i];
    
11.                         }
    
12.                        
    
13.                         if(nextmax<arr[i]&&arr[i]<max){
    
14.                                
    
15.                                 nextmax=arr[i];
    
16.                         }
    
17.        
    
18.                        
    
19.                 }
    
20.                
    
21.                 System.out.println(nextmax);
    
22.                
    
23.         }

复制代码

我么用排序

1. package oo;
   
2. 
   
3. public class SecondMax {
   
4. 
   
5.         public static int getSecondMax(int arr[]){
   
6.                 int secondMax=arr[0];               
   
7.                 for(int y=0;y<arr.length;y++){        //遍历数组，看谁是第二大数
   
8.                         int sign=0;                                        //做数量标记，标记一下。因为比第二大数大的只有一个数
   
9.                         for(int x=0;x<arr.length;x++){        //遍历数组与上层for循环比较
   
10.                                 if(arr[y]<arr[x])
    
11.                                         sign++;                                        //记录在数组中比arr[y]大的数有几个                       
    
12.                         }
    
13.                         if(sign==1){                                        //如果正好为一说明这个就是第二大数，用secondMax记录下来
    
14.                                 secondMax=arr[y];
    
15.                                 break;                                                //找到第二大数就不用再循环了，节省时间。跳出循环
    
16.                         }
    
17.                 }
    
18.                 return secondMax;
    
19.         }
    
20.         public static void main(String[] args) {
    
21.                 int[] arr={1,1,2,3,5,8,13,21,34,55};
    
22.                 int secondMax=getSecondMax(arr);
    
23.                 System.out.println("第二大数为"+secondMax);
    
24.         }
    
25. 
    
26. }
    

复制代码

再献上一种方法

1. package oo;
   
2. 
   
3. public class SecondMax2 {
   
4.         public static int getSecondMax(int arr[]){
   
5.                 for (int x=0;x<2 ;x++ ){                //这里利用了个冒泡排序，因为冒泡排序的特点（顺序从后往前排）
   
6.                                                                                 //又因为求得是第二大数，所以只需循环两次就可以了
   
7.                         for (int y=0;y<arr.length-x-1 ;y++ ){
   
8.                              if(arr[y]>arr[y+1]){
   
9.                                      int temp = arr[y];
   
10.                                      arr[y] = arr[y+1];
    
11.                                      arr[y+1]=temp;   
    
12.                              }  
    
13.                          }
    
14.                 }
    
15.                 return arr[arr.length-2];
    
16.         }
    
17.         public static void main(String[] args) {
    
18.                  int[] arr={1,1,2,3,5,8,13,21,34,55};
    
19.                  System.out.println(getSecondMax(arr));
    
20.         }
    
21. }
    

复制代码

1. import java.util.Arrays;
   
2. 
   
3. //哈哈，太简单了，你要次大值是吧，次大值来啦，不用循环
   
4. public class classIs12 {
   
5.         public static void main(String[] args){
   
6.                 int[] arr={18,1,1,2,3,5,8,13,21,34,55};
   
7.                 Arrays.sort(arr);
   
8.                 System.out.println(arr[arr.length-2]);
   
9.                
   
10.         }
    
11. 
    
12. }

复制代码

借用一位版主的经典：小手一抖，技术分到手！

package test;

public class Array {
       
        public int getMax(int[] a)

        {
                if(a==null)
                        return 0;
                int m=a[0];
        for(int i=0; i<a.length; i++)               
        {
                if(m<a[i])
                        m=a[i];
        }
        return m;
        }

        public static void main(String[] args)
        {
                System.out.println(new Array().getMax(new int[]{2,3,4,6,76,7,7,7,4,2,12,1,342}));
        }
}

1. class MaxMcDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr = new int[]{1,6,34,43,64,85,99,55,66,89};
   
6.                 int max = arr[0];
   
7.                 int mc = arr[0];
   
8.                 for (int i = 0; i< arr.length;i++ )
   
9.                 {
   
10.                                 System.out.println(arr[i]+"\t");
    
11.                         if (arr[i]>mc)
    
12.                         {
    
13.                                 if (arr[i]>max){
    
14.                                         max=arr[i];
    
15.                                 }else{
    
16.                                
    
17.                                         mc =arr[i];
    
18.                                 }
    
19.                         }
    
20.                 }
    
21.                 System.out.println(max+"和"+mc);
    
22.         }
    
23. }
    

复制代码

利用API中提供的线程的数组排序，然后在求值！API中提供的方法效率会高点。

import java.util.Arrays;
public class text {
        public static void main(String[] args) {
                int [] s={2,3,1,5,6,4,7};
        int preMax=getArrayPreMax(s);
        System.out.println("数组的次最大值是："+preMax);
        }
        public static int getArrayPreMax(int [] s){
                Arrays.sort(s);
                return s[s.length-2];
        }
}

希望对你有帮助！

想一想，感觉次大值和最值没什么区别嘛，不过提的还是不错的