递归基础练习1

1、求和

package com.wangymd.recursive;

/**
 * @desc 数组递归求和
 * @author wangymd
 * @data 2022-07-03 15:35:13
 */
public class SumTest {

    public static void main(String[] args) {
        int[] array1 = { 1, 2, 3, 4, 5, 6, 7, 8};
        System.out.println(sum(array1, 0));
    }

    public static int sum(int[] array, int index) {
        if (index == array.length) {
            return 0;
        } else {
            return array[index] + sum(array, index + 1);
        }
    }
}

2、数组是否排序判断

package com.wangymd.recursive;

/**
 * @desc 数组是否有序递归
 * @author wangymd
 * @data 2022-07-03 15:33:55
 */
public class ArrayIsSortedTest {

    public static void main(String[] args) {
        int[] array1 = { 1, 2, 3, 4, 5 };
        System.out.println(isSorted(array1, array1.length, "asc"));
        int[] array2 = { 1, 2, 3, 6, 5 };
        System.out.println(isSorted(array2, array2.length, "asc"));
        
        int[] array3 = { 5, 4, 3, 2, 1 };
        System.out.println(isSorted(array3, array3.length, "desc"));
        int[] array4 = { 5, 4, 3, 4, 1 };
        System.out.println(isSorted(array4, array4.length, "desc"));
    }

    public static boolean isSorted(int[] array, int index, String type) {
        if (index == 1) {
            return true;
        }
        
        if("desc".equalsIgnoreCase(type)){
            return array[index - 1] >= array[index - 2] ? false : isSorted(array, index - 1, type);
        }else if("asc".equalsIgnoreCase(type)){
            return array[index - 1] <= array[index - 2] ? false : isSorted(array, index - 1, type);
        }else{
            return false;
        }
    }
}

3、阶乘

package com.wangymd.recursive;

/**
 * @desc 递归
 * @author wangymd
 * @data 2022-07-03 15:32:53
 */
public class FactorialTest {

    public static void main(String[] args) {
        System.out.println(factorial(6));
    }
    
    /**
     *     递归阶乘
     * @param n
     * @return
     */
    public static int factorial(int n) {
        if(n == 0) {
            return 1;
        }else {
            return n * factorial(n - 1);
        }
    }
}

4、汉诺塔

①

package com.wangymd.recursive;

/**
 * @desc 递归 https://blog.csdn.net/question_mark/article/details/100907008
 * @author wangymd
 * @data 2022-07-03 15:35:37
 */
public class HanoiTest {

    public void hanoi(int n, char A, char B, char C) {
        if (n == 1) {
            move(A, C);//最大的圆盘从A移动到C
            return;
        }
        hanoi(n - 1, A, C, B);//C为辅助
        move(A, C);
        hanoi(n - 1, B, A, C);//A为辅助
    }

    private void move(char A, char C) {
        System.out.println("move: " + A + "----->" + C);
    }

    public static void main(String[] args) {
        HanoiTest hanoiTest = new HanoiTest();
        hanoiTest.hanoi(4, 'A', 'B', 'C');//移动A到C
    }
}

②

package com.wangymd.recursive;

import java.util.Stack;

/**
 * @desc 递归 https://blog.csdn.net/question_mark/article/details/100907008
 * @author wangymd
 * @data 2022-07-03 15:36:32
 */
public class HanoiTest2 {
    
    public static Stack<Integer> hanoiA = new Stack<Integer>();
    public static Stack<Integer> hanoiB = new Stack<Integer>();
    public static Stack<Integer> hanoiC = new Stack<Integer>();
    
    public static Integer times = 0;

    public void hanoi(int n, Stack<Integer> A, Stack<Integer> B, Stack<Integer> C) {
        if (n == 1) {
            move(A, C);//最大的圆盘从A移动到C
            return;
        }
        hanoi(n - 1, A, C, B);//C为辅助,n-1移动到B
        move(A, C);//A最下面的移动到C
        hanoi(n - 1, B, A, C);//A为辅助，B上n-1个移动到C
    }

    private void move(Stack<Integer> A, Stack<Integer> C) {
        System.out.println("<<<<<<<<第" + (++times) + "移动>>>>>>>>");
        C.push(A.pop());
        System.out.println("移动后hanoiA:" + hanoiA + " ,hanoiB:" + hanoiB + " ,hanoiC:" + hanoiC);
    }

    public static void main(String[] args) {
        HanoiTest2 hanoiTest = new HanoiTest2();
        
        hanoiA.push(1);
        hanoiA.push(2);
        hanoiA.push(3);
        hanoiA.push(4);
        hanoiA.push(5);
        hanoiA.push(6);
        
        System.out.println("移动前hanoiA:" + hanoiA);
        hanoiTest.hanoi(hanoiA.size(), hanoiA, hanoiB, hanoiC);//移动A到C
        System.out.println("移动完成hanoiC:" + hanoiC);
    }
}