冒泡算法和递归算法demo

package com.kindess.springbootswager.controller;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author kindess
 * @description 测试demo
 */
public class Test {
    /**
     * 递归算法
     *
     * @param num
     * @return
     */
    public static int countNum(int num) {
        //求和：1+2+...+num
       /* if (num > 0) {
            return num + countNum(num - 1);
        }
        return 0;*/
        //阶乘：1*2*...+num
        if (num <= 1) {
            return 1;
        }
        return num * countNum(num - 1);
    }

    /**
     * 题意：一个人赶着鸭子去每个村庄卖，每经过一个村子卖去所赶鸭子的一半又一只。
     * 这样他经过了七个村子后还剩两只鸭子，问他出发时共赶多少只鸭子？经过每个村子卖出多少只鸭子？
     * 
     * 算法步骤：
     * 1) 令num等于2，n等于7；
     * 2) 计算前一天的总鸭子数量num = (num + 1) * 2；
     * 3) 计算并输出第n天卖掉的鸭子数量；
     * 4) 将n减去1，判断n是否大于0，若是，则输出总鸭子数量num，否则，递归调用函数继续进行计算。
     *
     * @param num     最后一天剩余的鸭子的数量
     * @param counter 村庄的个数
     * @return
     */
    public static int duck_sale(int num, int counter) {
        num = (num + 1) * 2;
        System.out.println("第" + counter + "个村子卖出的鸭子的数量是：" + (num / 2 - 1));
        //计数器减1
        counter--;
        if (counter > 0) {
            //说明前面鸭子没卖完  递归调用方法 算出该村子卖出的鸭子的数量
            duck_sale(num, counter);
        } else {
            //说明鸭子卖完了
            System.out.println("鸭子的总数是：" + num);
        }
        return num;
    }

    /***
     * 角谷定理。输入一个自然数，若为偶数，则把它除以2，若为奇数，则把它乘以3加1。经过如此有限次运算后，总可以得到自然数值1。
     * 求经过多少次可得到自然数1。
     * 如：输入22，
     * 输出 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1
     * STEP=16
     *
     * 算法步骤：
     * 1)定义计数器counter=0 输入自然数的值
     * 2)判断n 是否为偶数，若是，则n=n/2 若不是，则n=n*3+1
     * 3)判断n是否等于1 若是，则输出counter，若不是继续 调用jiaogu()
     *
     * @param n 输入的自然数 所要求的数值
     * @param counter 输出最后结果所需要的调用几次
     * @return
     */
    public static int jiaogu(int n, int counter) {
        //这个计数器不可以在这里赋值的，这样每一次调用方法进来之后，都会重置counter的值
        //int counter = 1;
        if (n == 1) {
            return 1;
        } else {
            //计数器+1
            counter++;
            if (n % 2 == 0) {
                n = n / 2;
            } else {
                n = n * 3 + 1;
            }
            System.out.println("输出当前自然数的值是：" + n);
            //递归调用
            jiaogu(n, counter);
        }
        return counter;
    }

    public static void main(String[] args) {
        System.err.println("地归阶乘：" + countNum(5));
        System.err.println("递归案例：" + duck_sale(2, 2));
        System.err.println("角谷定理案例：" + jiaogu(3, 3));

        System.err.println("********************冒泡排序****************");
        int[] arr = {5, 12, 58, 98, 2, 1, 5, 36, 0};
        //外层循环控制循环趟数
        for (int i = 1; i < arr.length; i++) {
            //内层循环控制每一趟排序多少次
            for (int j = 0; j < arr.length - i; j++) {
                //控制排序结果，小于就是降序，大于就是升序
                if (arr[j] > arr[j + 1]) {
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
        System.out.println("输出升序后的数组:");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        System.err.println("********************集合排序****************");
        List<Integer> list = new ArrayList<Integer>();
        list.add(10);
        list.add(40);
        list.add(30);
        list.add(20);
        list.add(11);
        //list.sort(Integer::compareTo);
        Collections.sort(list);
        System.err.println(list);
    }
}

标题