Java算法——循环、递归实现—阶乘、Fibonacci数列、二分查找、回文字符串、杨辉三角

阶乘

源代码

public class Factorial {
    //循环阶乘
    public static int forFavtorial(int n){
        int result = 1;
        if(n == 1){
            return 1;
        }
        for (int i = 1; i <= n; i++) {
            result *= i;
        }
        return result;
    }

    //递归阶乘
    public static int recurFavtorial(int n){
        if(n == 1){
            return 1;
        }
        return recurFavtorial(n-1)*n;
    }

    public static void main(String[] args) {
        System.out.println(Factorial.forFavtorial(6));
        System.out.println(Factorial.recurFavtorial(6));
    }
}

测试

Fibonacci数列

源代码

public class Factorial {
    //循环阶乘
    public static int forFavtorial(int n){
        int result = 1;
        if(n == 1){
            return 1;
        }
        for (int i = 1; i <= n; i++) {
            result *= i;
        }
        return result;
    }

    //递归阶乘
    public static int recurFavtorial(int n){
        if(n == 1){
            return 1;
        }
        return recurFavtorial(n-1)*n;
    }

    public static void main(String[] args) {
        System.out.println(Factorial.forFavtorial(6));
        System.out.println(Factorial.recurFavtorial(6));
    }
}

测试

二分查找

源代码

public class BinarySearch {
    //循环二分查找
    public static int forBinarySearch(int[] array,int value){
        //记录是否找到
        int flag = -1;
        //记录 左边界and右边界
        //定义工具变量
        int left = 0;
        int right = array.length;
        int mid = 0;
        //while循环查找 左边界小于有边界
        while (left <= right){
            mid = (left + right)/2;
            if(array[mid] == value){//找到value 返回1
                flag = 1;
                left = right + 1;
            }else if(array[mid] > value){//大于目标值向左查找
                right = mid - 1;
            }else{//小于目标值向右查找
                left = mid + 1;
            }
        }
        return flag;
    }

    //递归二分查找
    public static int RecurBinarySearch(int[] array,int left,int right,int value){
        //左边界小于右边界 继续查找
        if(left <= right){
            int mid = (left + right)/2;
            //等于value 找到返回 1
            if(array[mid] == value){
                return 1;
            }
            //大于value 查找mid左边
            if(array[mid] > value){
                return RecurBinarySearch(array,left,mid - 1,value);
            }
            //小于value 查找mid右边
            return RecurBinarySearch(array,mid + 1,right,value);
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] num = {11,22,33,44,54,66,100};
        System.out.println(Arrays.toString(num));
        System.out.println(BinarySearch.forBinarySearch(num,56));
        System.out.println(BinarySearch.RecurBinarySearch(num,0,num.length,54));
    }
}

测试

回文字符串

源代码

public class PalindromeString {

    //循环产生回文字符串
    public static String getForPalindrome(String str){
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(str);
        for (int i = str.length() - 1; i >= 0 ; i--) {
            stringBuilder.append(str.charAt(i));
        }
        return stringBuilder.toString();
    }

    //循环判断字符串是否是回文字符串
    public static boolean isForPalindrome(String str){
        for (int i = 0; i < str.length(); i++) {
            if(str.charAt(i) != str.charAt(str.length()-1-i)){
                return false;
            }
        }
        return true;
    }

    //递归判断字符串是否是回文字符串
    public static boolean isRecurPalindrome(String str,int n){
        if(str.charAt(n) != str.charAt(str.length()-1-n)){
            return false;
        }
        if(n == (str.length()/2)){
            return true;
        }
        return isRecurPalindrome(str,n+1);
    }

    //测试
    public static void main(String[] args) {
        System.out.println( PalindromeString.getForPalindrome("123"));
        System.out.println(PalindromeString.isForPalindrome("123421"));
        System.out.println(PalindromeString.isRecurPalindrome("123421",0));
    }
}

测试

杨辉三角

源代码

/**
 * @author hudongsheng
 * @date 2020/11/19 - 22:30
 * 杨辉三角
 * 1
 * 1 1
 * 1 2 1
 * 1 3 3 1
 * 1 4 6 4 1
 */
public class YanghuiTriangle {
    //循环
    public static int ForYanghuiTriangle(int x,int y){
        int[][] arrays = new int[5][5];
        //给第一列和对角线赋值
        for (int i = 0; i < arrays.length; i++) {
            arrays[i][0] = 1;
            arrays[i][i] = 1;
        }
        //给中间赋值
        for (int i = 2; i<arrays.length; i++) {
            for (int j = 1;j <= i;j++){
                arrays[i][j] = arrays[i-1][j-1] + arrays[i-1][j];
            }
        }
        return arrays[x-1][y-1];
    }

    //递归
    public static int recurYanghuiTriangle(int x,int y){
        if(y == 1 || x == y){
            return 1;
        }
        return recurYanghuiTriangle(x-1,y-1)+recurYanghuiTriangle(x-1,y);
    }

    public static void main(String[] args) {
        System.out.println(YanghuiTriangle.ForYanghuiTriangle(5,3));
        System.out.println(YanghuiTriangle.recurYanghuiTriangle(5,3));
    }

}

测试