Java程序设计实验（三）

实验三

1.用循环和递归两种方法实现 10的阶乘。
**代码如下：

package alltest;
//用循环和递归两种方法实现 10的阶乘
import java.util.Scanner;
public class test31201 {
   public static void main(String[] args) {
    	Scanner in= new Scanner(System.in);       //输入
    	System.out.println("请输入值（n>0）：");
    	int n= in.nextInt();
    	System.out.println("利用循环的方法求"+n+"的阶乘为："+"\t"+circleFactorial(n)+"\n");
    	System.out.println("利用递归的方法求"+n+"的阶乘为："+"\t"+recursiveFactorial(n)+"\n");
   }
   
   private static int circleFactorial(int n) {  //利用循环的方法求阶乘
   	 int sum= 1;
    	for (int i=1; i<=n; i++) {
     		sum*=i;
    	}
    	return sum;
   }
   
   private static int recursiveFactorial(int n) {  //利用递归的方法求阶乘
    	int sum=1;
    	if(n==1) {
     		return 1;
    	}else {
     		sum=n*recursiveFactorial(n-1);
     	return sum;
    	}
   }
 }

**输出结果：

2.int[]num={92,5,7,45,76,103,44,23,7,98,100};
（利用递归，求数组中的最大值。）
**代码如下：(方法1：递归正着推)

package alltest;
public class test31203 { 
	public static void main(String[] args) {
  		int []num = {92,5,7,45,76,103,44,23,7,98,100}; 
  		System.out.println(maxnum(num,0));
  }
	public static int max(int a, int b) {    //定义一个比较两个数值大小的函数
 	 	return a>b ? a : b;
 }
 /*采用的递归思路是：若长度为L的数组最大值，
  即是求 数组前L-1个长度的最大值 和最后一个数组元素的相对较大值*/
public static int maxnum(int[] a, int begin) {
     	int length = a.length - begin;   //a.length指的是该数组的长度11
     	if(length == 1) {
     	return a[begin];
     	}else {
     	return max(a[begin], maxnum(a, begin+1));
	}
     }
}
 

对应的图解：

**代码如下：（方法2：递归反着推）

package alltest;

class two {

 private static int max(int a,int b){ //定义一个比较两个数值大小的函数
		return a>b?a:b; //Math.max(int a,int b)
}

 public static int maxNum(int[] num,int endindex){   
 /*采用的递归思路是：若求长度为L的数组最大值，
    即是求 数组前L-1个长度的最大值 和最后一个数组元素的相对较大值*/
   	if(endindex==0){  //从数组的第一个数开始比较 
     	   return num[0];
        }
          return max(num[endindex],maxNum(num,endindex-1));//Math.max();
 }

 public static void main(String[] args){
        int num[]= {92,5,7,45,76,103,44,23,7,98,100};
 	System.out.print(maxNum(num,num.length-1));//调用的就是递归定义的方法
 }
}
/*maxNum(num,10)//总共是11个元素，所以下标-1
 第一次的return：          max(num[10],maxNum(num,9))
 第二次                        max(num[9],maxNum(num,8)) 
 第三次                            max(num[8],,maxNum(num,7)) 
                         92<-- max(num[3],maxNum(num,2)) 
                           92<--max(num[2],maxNum(num,1)) 
    			     92<--max(num[1],maxNum(num,0);)
                                 92
*/

**代码如下：（方法3：数组中最大值 k存储最大元素的值）

public static void main(String[] args) {
 int[]num={92,5,7,45,76,103,44,23,7,98,100};
 int i, k;
 k=num[0];
 for( i=1;i<=10;i++) {
  if (num[i]>k) {
   k=num[i];
  } 
 }
 System.out.println("数组中最大的值为"+k);
}
}

**代码如下：（方法4：正着推的程序改写，重载）

package hello;
import java.util.Scanner;
//java递归实现求数组最大值
public class three {
	public static void main(String []args){
         	Scanner sc = new Scanner(System.in);
        	 int n;
         	int []a;
         	a = new int[100];
         	n = sc.nextInt();
         	for(int i=0;i<n;i++){
             	a[i] = sc.nextInt();
        	 }
         	System.out.println(max(a,n));
     	}
 	static int max(int []arr,int n){   //方法重载
        	return max(arr,0,n);
     	}
	static int max(int []arr,int from,int n){  //方法重载
         	if(from==n-1){
             		return arr[from];   //终止语句
         	}
                else{
             		return Math.max(arr[from],max(arr,from+1,n));//递归关键句，正着推
         }
     }
 }

实验截图如下：