Java中递归、数组反转、二分查找、冒泡排序

递归

递归方法调用:方法自己调用自己的现象就称为递归

递归的分类*直接递归 间接递归

• 直接递归:方法自身调用自己

  public void methodA(){
      methodA();
  }
  

• 间接递归:在方法A()中调用方法B(),在方法B()中调用方法C(),在方法C()中调用方法A();

  public void A(){
      methodB();
  }
  

  public void B(){
      methodC();
  }
  

  public void C(){
      method();
  }
  

说明:

• 递归方法包含了一种"隐式循环"
• 递归方法会 重复执行 某段代码，但这种重复执行无须循环控制
• 递归一定要向 已知方向 递归，否则这种递归就变成了无穷递归，停不下来，类似于 死循环 。最终 发生 栈内存溢出 。

注意:

• 递归调用会占用大量的系统堆栈,内存耗用多,在递归层次多时速度比循环慢的多,所以慎用
• 在要求高性能的情况下尽量避免使用递归,递归调用即花时间又花内存

例1:输入一个数,倒着输出至1

public class Demo01 {
    public static void main(String[] args) {
        method(5);
    }

    public static void method(int i){
        if(i==1){
            System.out.println(i);
            return;
        }
        System.out.println(i);
        i--;
        method(i);
    }
}

例2:求n的阶乘 n!

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(method(3));
    }
    public static int method(int n){
        if(n == 1){
            return n;
        }
        return n * method(n-1);
    }
}

例3:计算斐波那契数列（Fibonacci）的第n个值

public class Demo03 {
    public static void main(String[] args) {
        System.out.println(method(12));
    }
    public static int method(int month){
        if(month == 1 || month == 2){
            return 1;
        }
        return method(month - 1)+method(month - 2);
    }
}

二分查找(折半查找)

• 前提:数组元素是有序的
• 查找思想:每次查找都干掉一半,再另一半中查找,找不着,再干一半

思路:

1. 怎么找中间索引

   int min = 0;
   int max = arr.length -1 ;
   int mid = (min + max) / 2;
   

2. 怎么查

   if(key>arr[mid]){
       min = mid + 1;
   }
   if(key<arr[mid]){
       max = mid - 1;
   }
   if(key == arr[mid]){
       sout("找到了")
   }
   

3. 什么时候算找不到了

   min > max的时候找不到了
   

实现代码

//while循环
public class BinarySearch{
    public static void main(String[] args){
        int arr[] = {1,2,3,4,5,6,7,8};
        int key = 6;
        int min = 0;
        int max = arr.length -1 ;
        int mid = 0;
        while(min <= max){
            mid = (min + max) / 2;
            if(key > arr[mid]){
                min = mid + 1; 
            }
            if(key < arr[mid]){
                max = mid - 1;
            }
            if(key == arr[mid]){
                System.out.println(mid);
                break;
            }
        }
    }
}

//如果找不到,请输出对应的提示信息
public class BinarySearch{
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5,6,7,8,9};
        int key = 10;
        int min = 0;
        int max = arr.length -1 ;
        int mid = 0;
        boolean isFlag = false;
        while(min <= max){
            mid = (min+max)/2;
            if(key > arr[mid]){
                min = mid + 1 ;
            }
            if(key < arr[mid]){
                max = mid - 1;
            }
            if(key == arr[mid]){
                isFlag = true;
                System.out.println("找到了,数组下标为"+mid);
                break;
            }
        }
        if(isFlag){
            System.out.println("没有找到");
        }
    }
}

数组反转

实现思想:数组对称的位置元素互换

思路:

1. 确定交换几次
2. 谁和谁交换

1.两边的索引确定
	int min = 0;
	int max = arr.length - 1;
2.怎么换
	int temp = arr[min];
	arr[min] = arr[max];
	arr[max] = temp;
3.换完之后更改迭代
	min++;
	max--;
4.什么时候结束
	min = max;
	或
	min > max时 停止
	当min < max 时交换

方式一:单指针反转

//单指针反转
//交换一半即可 即i < arr.length / 2
public class ArrayReverse{
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5,6,7,8};
        for(int i = 0; i < arr.length / 2;i++){
            int temp = arr[i];
            arr[i] = arr[arr.length -1 -i];
            arr[arr.length-1-i] = temp;
        }
        System.out.println("反转结束");
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + " ");
        }
    }
}

方式二:双指针反转

//双指针反转
// 交换区间 i < j
public class ArrayReverse{
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5,6,7,8};
        for(int i = 0,j = arr.length -1 ; i < j;i++,j--){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        System.out.println("反转结束");
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + " ");
        }
    }
}

方式三:引入第二个数组赋值达到反转目的

//引入第二个数组
//赋值区间: i < arr.length
public class ArrayReverse {
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5,6,7,8};
        int[] arr1 = new int[arr.length];
        for(int i = 0;i < arr.length ; i++){
            arr1[i] = arr[arr.length - 1 -i];
        }
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+" ");
        }
    }
}

冒泡排序

排序，都要进行数组 元素大小的比较，再进行位置的交换。冒泡排序法是采用数组中相邻元素进行比较换位。

思路:

1. 比较相邻的元素,如果第一个比第二大(升序),就交换他们两个
2. 对每一个相邻的元素进行同样的工作,从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。

1.数组长度为n
    比较n-1圈
    每一圈少比较1次
2.怎么表示前面一共元素和后面一共元素比较呐
    arr[i]和arr[i+1]比较
    
    int i = 0; i < arr.length - 1;i++		//比较圈数
        int j = 0;j < arr.length - 1 -i;j++		
         //比较次数  arr.length-1是为了arr[i]和arr[i+1]比较
         //         arr.length-1-i是因为每圈都要少比1次,每圈循环将最大的都排在了后面

实现代码

public class BubbleSort{
    public static void main(String[] args){
        int[] arr = {8,5,7,4,9,21,43,48};
        for(int i = 0;i < arr.length -1 ;i++){
            for(int j = 0;j < arr.length - 1 - i;j++){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}