java最大值函数_用java编写找最大值函数?

你好，好多种办法。我给你写几种经典的排序吧，最大值就在第一个(倒序)或者最后一个(从小到大)。

首先方便输出，定义一个工具类

public class PrintUtil {

public static void print(int[] array){

for(int i=0;i

System.out.print(array[i] + " ");

}

System.out.println();

}

}

第一种：冒泡排序

public class BubblingSort {

/*

* 算法思想->升序

* 1、比较相邻两项，若为逆序，则交换

* 2、每次比较的结果就是将最大项浮到数组尾

* 算法分析：

* ------- 最坏情况 --------

* 比较次数：(n-1) + (n-2) + ... + 1 = n*(n-1)/2

* 交换次数：[(n-1) + (n-2) + ... + 1]*3 = 3*n*(n-1)/2

* 所以n元选择排序需要的主要操作次数是：n*(n-1)/2+3*n*(n-1)/2=2*n*n-2*n

* 结论：O(n*n)阶

* ------- 最好情况 --------

* 比较次数：n-1

* 交换次数：0

* 所以n元选择排序需要的主要操作次数是：n-1

* 结论：O(n)阶

*/

public void bubbingSort(int[] array){

int len = array.length ;

for(int i=len-1;i>0;i--){

boolean flag = false ;

for(int j=0;j

if(array[j]>array[j+1]){

int temp = array[j] ;

array[j] = array[j+1] ;

array[j+1] = temp ;

flag = true ;

}

}

if(!flag){

break ;

}

System.out.print("第" + (5-i) + "趟的排序结果为：" );

PrintUtil.print(array) ;

}

}

public static void main(String[] args) {

int[] array = {29,10,14,37,13} ;

//int[] array = {37,29,14,13,10} ; //最差情况

//int[] array = {10,13,14,29,37} ; //最好情况

BubblingSort ss = new BubblingSort();

ss.bubbingSort(array);

PrintUtil.print(array) ;

}

}

第二种：插入排序

public class InsertSort {

/*

* 算法思想->升序

* 1、将一个数组的元素分成两部分，前半部分为有序数组

* 2、每一次取后半部分的第一个元素，将该元素插入到有序数组中

* 算法分析：

* ------- 最坏情况 --------

* 比较次数：1 + 2 + ... + (n-1) = n*(n-1)/2

* 移动次数：

* 内部循环：1 + 2 + ... + (n-1) = n*(n-1)/2

* 外部循环：2*(n-1) OR 2

* 所以n元选择排序需要的主要操作次数是：n*(n-1)/2 + n*(n-1)/2 + 2*(n-1) = n*n+n-2

* 结论：O(n*n)阶

*/

public void insertSort(int[] array){

for (int i = 1; i < array.length; i++) {

int temp = array[i] ;

for(int j= i-1; j >= 0; j--){

if(temp > array[j])

break ;

if(temp < array[j]){

array[j+1] = array[j] ;

if( j != 0 && temp > array[j-1]){

array[j] = temp ;

break ;

}

if(j == 0){

array[0] = temp ;

}

}

}

System.out.print("第" + i + "趟的排序结果为：" );

PrintUtil.print(array) ;

}

}

public static void main(String[] args) {

int[] array = {29,10,14,37,13} ;

InsertSort ss = new InsertSort();

ss.insertSort(array);

PrintUtil.print(array) ;

}

}

第三种：选择排序

public class SelectSort {

/*

* 算法思想->升序

* 1、找到最大的元素，与最后一个元素交换

* 2、除去最后一个元素外，在数组的剩余项中查找最大项，并与倒数第二个元素交换

*

* 算法分析：

* 比较次数：n*(n-1)/2

* 交换次数：3*(n-1)

* 所以n元选择排序需要的主要操作次数是：n*(n-1)/2+3*(n-1)=n*n/2+5*n-3

* 结论：O(n*n)阶

*/

public void selectSort(int[] array){

int len = array.length ; //记录数组的长度

int scope = len ; //遍历范围

for(int i=0;i

int max = array[0] ; //数组的最大元素

int index = 0 ; //记录最大元素的下标

for(int j=1;j

if(max < array[j]){

max = array[j] ;

index = j ;

}

}

int temp = array[scope-1] ;

array[scope-1] = array[index] ;

array[index] = temp ;

System.out.print("第" + (i+1) + "趟的排序结果为：" );

PrintUtil.print(array) ;

scope -- ;

}

}

public static void main(String[] args) {

int[] array = {29,10,14,37,13} ;

SelectSort ss = new SelectSort();

ss.selectSort(array);

PrintUtil.print(array) ;

}

}

其余的都比较复杂就不给你多写了。

其实很简单的算法，就是遍历这N个数，没遇到一个大的值，就去赋给max，最后输出max，但是这个没什么技术含量，所以在最后说明下。