「java查找极值」怎么找极值

本篇文章给大家谈谈java查找极值，以及怎么找极值对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、编写JAVA程序,从十个数中找出最大值
• 2、用java编写找最大值函数
• 3、Java求最大值的三种方法
• 4、如何用Java找出一个整数数组中最大的值，并返回最大值的数组下标，尤其是有两个或是三个最大值时？

编写JAVA程序,从十个数中找出最大值

import java.util.Scanner;

public class Test {

public static void main(String args[]){

int num[]=new int[10];

int max;

Scanner scan=new Scanner(System.in);

System.out.print("请输入10个数字:");

for(int i=0; i10; i++){

num[i]=scan.nextInt();

}

max=num[0];

for(int i=1; i10; i++){

if(maxnum[i]) max=num[i];

}

System.out.println("最大值是"+max);

}

}

用java编写找最大值函数

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

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

public class PrintUtil {

public static void print(int[] array){

for(int i=0;iarray.length;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;i0;i--){

boolean flag = false ;

for(int j=0;ji;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;ilen-1;i++){

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

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

for(int j=1;jscope;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，但是这个没什么技术含量，所以在最后说明下。

Java求最大值的三种方法

普通方法：

public class Max {

public static void main(String[] args) {

double[] myList = {1.9, 2.9, 3.4, 3.5,10,11,15,100,-1,-4.5}; //定义一维数组

double num = myList[0]; //0为第一个数组下标

for (int i = 0; i myList.length; i++) { //开始循环一维数组

if (myList[i] num) { //循环判断数组元素

num = myList[i]; } //赋值给num，然后再次循环

}

System.out.println("最大值为" + num); //跳出循环，输出结果 }

}

三元运算符：

public class Max {

public static void main(String[] args) {

double[] myList = {1.9, 2.9, 3.4, 3.5,10,11,15,1,-1,-4.2}; //定义一维数组

double num = myList[0]; //0为第一个数组下标

for (int i = 0; i myList.length; i++){ //开始循环一维数组

num=(myList[i] num?num: myList[i]); //三元运算符，详情看注解

}

System.out.println("最大值为" + num); //跳出循环，输出结果

}}

一般函数/方法：

public class Max {

double[] myList = {1.9, 2.9, 3.4, 100,3.5,10,11,12,13,-1};

double num = myList[0];

void getValue(){ //创建一般方法

for (int i = 0; i myList.length; i++) {

num=(myList[i] num?num: myList[i]);//三元运算符

}

System.out.println("最大值为" + num);

}

public static void main(String args[]){

Max max=new Max(); //创建对象

max.getValue(); //通过对象调用一般方法

}

}

三种求最大值的方法

如何用Java找出一个整数数组中最大的值，并返回最大值的数组下标，尤其是有两个或是三个最大值时？

用System.out.println(j);   //输出最大值下标即可。

一、源程序为：public class Test2 {public static void main(String[] args) {int [] arr={23,12,32,13,31,56,43}sort(arr);System.out.format("%d",+arr[6]);// TODO Auto-generated method stub}public static void  sort(int  azz[]){int t;for(int i=0;iazz.length-1;i++){ if(azz[i]azz[i+1]){ t=azz[i];azz[i]=azz[i+1]azz[i+1]=t;}}}}。

二、此程序使用了数组：有关数组：声明格式 ：    数据类型  数组名[ ]；  或    数据类型   [  ]   数组名；同时声明与创建数组的格式为：数据类型 数组名[ ]=new 数据类型 [ size ]其中，new用来给数组分配内存，size用来定义数组的长度。

三、函数调用：sort(arr);形式：public class Test {public static void main(String[] args) {sort(arr);}public static void  sort(int  azz[]){}}。

四、冒泡排序第一次，找出最大的值。比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

java查找极值的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于怎么找极值、java查找极值的信息别忘了在本站进行查找喔。