一、递归

1.按顺序打印一个数字的每一位.

例如 1234 打印出1 2 3 4

//1.按顺序打印一个数字的每一位.
//例如 1234 打印出1 2 3 4
public static void print(int num){
if(num>9){
print(num/10);
}
System.out.print( " "+num%10);
}
public static void main(String[] args) {
int n=1234;
print(n);
}
//输出结果：
1 2 3 4

2.递归求1+2+3+…+10.

 //2.递归求1+2+3+…+10.
//转化为n+add(n-1)
public static int add(int num){
if(num==1){
return 1;
}
return num+add(num-1);
}
public static void main(String[] args) {
int n=10;
int ret=add(n);
System.out.println("ret="+ret);
}
//输出结果：
ret=55

3.写一个递归方法，输入一个非负整数，返回组成它的数字之和.

例如，输入1729，则应该返回1+7+2+9，它的和是19

//3.写一个递归方法，输入一个非负整数，返回组成它的数字之和.
//例如，输入1729，则应该返回1+7+2+9，它的和是19
public static int numAdd(int num){
if(num<10){
return num;
}
return num%10 +numAdd(num/10);
}
public static void main(String[] args) {
int n=1729;
int ret=numAdd(n);
System.out.println("ret="+ret);
}
//输出结果
ret=19

4.求斐波那契数列的第N项

斐波那契数列指的是这样一个数列：
0，1，1，2，3，5，8…
这个数列从第3项开始，每一项都等于前两项之和。

/* 4.求斐波那契数列的第N项
斐波那契数列指的是这样一个数列：
0，1，1，2，3，5，8......
这个数列从第3项开始，每一项都等于前两项之和。*/
public static int fib(int n){
int last1=1;
int last2=1;
int cur=0;
for(int i=3;i<=n;i++){
cur=last1+last2;
last1=last2;
last2=cur;
}
return cur;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入N的值:");
int N = sc.nextInt();
int ret=fib(N);
System.out.println("斐波那契数列的第"+N+"项= "+ret);
}
//输出结果
请输入N的值:
5
斐波那契数列的第5项= 5

5.求 N 的阶乘

//求N的阶乘
//递归求阶乘
public static int factor(int n){
if(n==1){
return 1;
}else{
return n*factor(n-1);
}
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入N的值:");
int N=sc.nextInt();
int ret= factor(N);
System.out.println(N+"的阶乘为"+ret);
sc.close();
}
//输出结果
请输入N的值:
5
5的阶乘为120

6.求1！+2！+3！+4！+…+n!的和

//求1！+2！+3！+4！+........+n!的和
public static long factor(long n){
if(n==1){
return 1;
}
return n*factor(n-1);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入N的值:");
long N = sc.nextInt();
long sum = 0;
for (long i = 1; i <= N; i++) {
sum += factor(i);
}
System.out.println(sum);
sc.close();
}

7.青蛙跳台阶

问题：
一只青蛙一次可以跳1级台阶，也可以一次跳2级台阶，请问跳n级台阶，该青蛙一共有多少种跳法？

//7.青蛙跳台阶
//一只青蛙一次可以跳1级台阶，也可以一次跳2级台阶，请问跳n级台阶，该青蛙一共有多少种跳法？
//如果只有一阶，那么只有一种跳法。如果有两阶，那么有两种跳法(一次跳两级，一次一级跳两次)，
// 如果有n阶，到最后一步的时候要么是在n-1级台阶的地方，要么是在n-2级的地方。假设n阶时，有f(n)种跳法。
//f(1)=1,f(2)=2,f(n)=f(n-1)+f(n-2).可以发现是斐波那契数列。
public static int fibb(int n){
int last1=1;
int last2=2;
int cur=0;
for(int i=3;i<=n;i++){
cur=last1+last2;
last1=last2;
last2=cur;
}
return cur;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入青蛙跳台阶数:");
int n = sc.nextInt();
int ret=fibb(n);
System.out.println("青蛙跳"+n+"级台阶一共有"+ret+"种跳法");
}
//输出结果
请输入青蛙跳台阶数:
5
青蛙跳5级台阶一共有8种跳法

二、数组

1.数组转字符串

import java.util.Arrays;
public static void main(String[] args) {
//练习题
//数组转字符串
int[] arr ={1,2,3,4,5,6};
String newArr=Arrays.toString(arr);
System.out.println(newArr);
}
//运行结果
[1, 2, 3, 4, 5, 6]

使用这个方法后续打印数组就更方便一些。
Java中提供了java.util.Arrays 包，其中包含了一些操作数组的常用方法。

  自己写一个方法实现数组转字符串：

public static String toString(int[] array){
String strRet="[";
for(int i=0;i<array.length-1;i++){
strRet += array[i];
strRet += ",";
}
strRet +=array[array.length-1];
strRet +="]";
return strRet;
}
public static void main(String[] args) {
int[] array ={1,2,3,4,5,6};
String strArray=toString(array);
System.out.println(strArray);
}
//运行结果：
[1,2,3,4,5,6]

2.数组拷贝

public static void main(String[] args) {
//浅拷贝----> newArr和arr引用的是同一个数组
//因此newArr修改空间中内容之后，arr也可以看到修改的结果
int[] arr={1,2,3,4,5,6};
int[] newArr=arr;
newArr[0]=10;
System.out.println("newArr:"+Arrays.toString(arr));
//输出：newArr:[10, 2, 3, 4, 5, 6]
//使用Arrays中copyOf方法完成数组的拷贝:
//深拷贝---->copyOf方法在进行数组拷贝时，创建了一个新的数组
//arr和newArr引用的不是同一个数组
arr[0]=1;
newArr=Arrays.copyOf(arr,arr.length);
System.out.println("newArr:"+Arrays.toString(newArr));
//输出：newArr:[1, 2, 3, 4, 5, 6]
//因为arr修改其引用数组中内容时，对arrArr没有任何影响
arr[0]=10;
System.out.println("arr: "+Arrays.toString(arr));
System.out.println("newArr: "+Arrays.toString(newArr));
//输出:
// arr: [10, 2, 3, 4, 5, 6]
//newArr: [1, 2, 3, 4, 5, 6]
//拷贝某个范围
int[] newArr2=Arrays.copyOfRange(arr,2,4);
System.out.println("newArr2: "+Arrays.toString(newArr2));
//输出：newArr2: [3, 4]
//[from,to)
}

//自己实现拷贝
public static int[] copyOf(int[] arr){
int[] ret =new int[arr.length];
for(int i=0;i<arr.length;i++){
ret[i]=arr[i];
}
return ret;
}
public static void main(String[] args) {
int[] array7={9,6,2};
int[] array8=copyOf(array7);
System.out.println(Arrays.toString(array8));
}

copyOf是数组进行了深拷贝，即又创建了一个数组对象，拷贝原有数组中的所有元素到新数组中。因此，修改原数组，不会影响到新数组。

3.求数组中元素的平均值

给定一个整型数组，求平均值

public static double avg(int[] arr){
int sum=0;
for(int x:arr){
sum+=x;
}
return (double)sum/(double)arr.length;
}
public static void main(String[] args) {
int[] arr={1,2,3,4,5,6};
System.out.println(avg(arr));
}
//运行结果：
3.5

注意事项：结果要用double来表示。

4.查找数组中指定元素(顺序查找)

给定一个数组，再给定一个元素，找出该元素在数组中的位置。

public static void main(String[] args) {
int[] arr={1,2,3,10,5,6};
System.out.println(find(arr,10));
}
public static int find (int[] arr,int toFind){
for(int i=0;i<arr.length;i++){
if(arr[i]==toFind){
return i;
}
}
return -1;//表示没找到
}
//运行结果
3

5.查找数组中指定元素(二分查找)

针对有序数组，可以使用更高效的二分查找。有序分为"升序"和"降序"。
以升序数组为例，二分查找的思路是先取中间位置的元素，看要找的值比中间元素大 还是小。如果小就，就去左边找。否则就去右边找，直到找到为止。

 public static int binarySearch(int[] arr,int toFind){
int left=0;
int right=arr.length-1;
while(left<=right){
int mid=(left+right)/2;
if(toFind<arr[mid]){
//去左侧区间找
right=mid-1;
}else if(toFind>arr[mid]){
//去右侧区间找
left=mid+1;
}else{
//相等，说明找到了。
return mid;
}
}
//循环结束，说明没找到
return -1;
}
public static void main(String[] args) {
int[] arr={1,2,3,4,5,6};
System.out.println(binarySearch(arr,5));
}
//运行结果
4

数组元素个数越多，二分查找的优势越大。

6.数组排序(冒泡排序)

 public static void main(String[] args) {
int[] arr={4,3,2,7};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public
static void bubbleSort(int[] arr){
for(int i=0;i<arr.length;i++){
for(int j=1;j<arr.length-i;j++){
if(arr[j-1]>arr[j]){
int tmp=arr[j-1];
arr[j-1]=arr[j];
arr[j]=tmp;
}
}
}
}
//运行结果
[2, 3, 4, 7]

冒泡排序的性能比较低，Java中内置了更高效的排序算法

public static void main(String[] args){
int[] arr={9,5,2,7};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));

7.数组逆序

思路：设定两个下标，分别指向第一个元素和最后一个元素。交换两个位置的元素。然后让前一个下标自增，后一个下标自减，循环继续即可。

 public static void main(String[] args) {
int[] arr={1,2,3,4};
reverse(arr);
System.out.println(Arrays.toString(arr));
}
public static void reverse(int[] arr){
int left=0;
int right=arr.length-1;
while(left<right){
int tmp=arr[left];
arr[left]=arr[right];
arr[right]=tmp;
left++;
right--;
}
}
//运行结果
[4, 3, 2, 1]

8.给定一个整型数组, 判定数组是否有序（递增）

 public static void main(String[] args) {
int[] arr={1,2,3};
String a=Arrays.toString(arr);
Arrays.sort(arr);
String b=Arrays.toString(arr);
if(a.equals(b)){
System.out.println("是有序递增");
}else{
System.out.println("不是有序递增");
}
}
//运行结果：
是有序递增

9.实现一个方法 sum, 以数组为参数, 求数组所有元素之和.

 //实现一个方法 sum, 以数组为参数, 求数组所有元素之和.
public static int arraySum(int[] arr){
int sum=0;
for(int x:arr){
sum+=x;
}
return sum;
}
public static void main(String[] args) {
int[] arr1={1,2,3,4,5,6};
System.out.println(arraySum(arr1));
}
//运行结果：
21

10.改变原有数组元素的值

实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}

public static int[] transform(int[] arr){
int[] array5=new int[arr.length];
for(int i=0;i<arr.length;i++){
array5[i]=2*(arr[i]);
}
return array5;
}
public static void main(String[] args) {
int[] array4={1,2,3};
int[] array6=transform(array4);
System.out.println(Arrays.toString(array6));
}
//输出结果
[2, 4, 6]

11.打印数组

实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值.

//实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值.
public static void printArray(int[] arr){
for(int x:arr){
System.out.println(x);
}
}
public static void main(String[] args) {
int[] array2={1,2,3,4,5,6};
printArray(array2);
}
//运行结果
1
2
3
4
5
6

12.创建数组，并且赋初始值

创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100

public static void main(String[] args) {
//创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
int[] array3=new int[100];
for(int i=0;i<100;i++){
array3[i]=i+1;
System.out.print(array3[i]+" ");
}
}
//运行结果
//1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 

13.有一组数据，只有一个数字是出现一次，其他是两次，请找出这个数字。

 public static void main(String[] args) {
int[] arr = {1, 1, 2, 2, 3, 3, 4, 4, 5};
frequency(arr);
}
public static void frequency(int[] a) {
for (int i = 0; i < a.length; i++) {
int count = 0;//判断出现次数
for (int j = 0; j < a.length; j++) {
if (a[i] == a[j]) count++;
}
if (count == 1)
System.out.printf("只出现一次的数字是%d",a[i]);//只出现一次则输出该数据
}
}
//运行结果：
只出现一次的数字是5

14.调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。

 //调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。
public static void main(String[] args) {
int[] array11={1,8,4,6,2};
for(int i=0;i<array11.length;i++){
for (int j=i+1;j<array11.length;j++){
if(array11[j]%2!=0){
int tmp=array11[j];
array11[j]=array11[i];
array11[i]=tmp;
}
}
System.out.print(array11[i]+" ");
}
}
//运行结果：
1 8 4 6 2

最后

以上就是瘦瘦火龙果为你收集整理的递归及数组练习题一、递归二、数组的全部内容，希望文章能够帮你解决递归及数组练习题一、递归二、数组所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。