数据结构与算法-dljd-hgq

原创已于 2022-05-03 10:44:12 修改 · 758 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#排序算法 #算法 #其他

于 2022-05-02 11:38:38 首次发布

01 Java基础专栏收录该内容

17 篇文章

订阅专栏

本文探讨了递归算法在文件查找、数学问题（如斐波那契数列和迷宫求解）中的应用，并介绍了冒泡排序的原理和实例。通过这两个常见算法，展示了编程中的递归思想和解决实际问题的方法。

一递归算法

1 生活中的问题

解决程序中特殊的复杂的一些小问题，使代码变得更加简洁。
1. 文件夹查找，一层一层往下找指定名称的文件。
2. 可以解决各种数学问题，汉若塔，迷宫问题， 8皇后问题等等。各种算法的递归，如快排，归并排序，二分查找，分治算法等。
比较少用

2 解决方案：递归算法（有递》终点》有归，即有去》终点》有回）

3 官网配置：高效

（1）思想、流原

白话版1：小时候某些词的意思你不懂，要去查看新华字典。第一次查看得到第一种解释，你看不懂解释中的某些字。第二次，你又得查第一次解释中不懂的字词的意思。第三次，你得查看第二次解释中不懂的字词。第四次...。第五次......（递）。终于（条件尽头）都懂了，然后把前面n次查询得到的结果从后往前整合（归），得到这个词最终的解释。这就是我们常用的递归查找算法。
1. 把问题分解成多个同一类型的子问题，子问题是一个函数。
2. 确定第一个函数参数
3. 函数自己调用自己，每次调用时传入的参数是不同的。
4. 函数执行遇到return，遵守谁调用就将结果返回给谁。
5. 直到条件尽头。

（2）案例1：斐波那契数列 1 1 2 3 5 8 13 21 34 55 89 144

规律：

代码：

package com.bjpowernode.rabbitmq.config;

//斐波那契数列 1 1 2 3 5 8 13 21 34 55 89 144
public class Test {
    public static int fun (int num){
        if(num == 1){       //  初始条件
            return 1;
        }else if(num == 2){ //  初始条件
            return 1;
        }else {
            return fun(num - 2) + fun(num - 1);   //  结束条件
        }
    }
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++){//  打印10个数
            System.out.println(fun(i));
        }
    }
}

（3）案例2：迷宫

规律：

代码：

package com.bjpowernode.rabbitmq.config;

/**
 * author:韩国庆
 * date:2021/2/27 16:46
 * version:1.0
 */
public class Maze {

    public static void main(String[] args) {

        int[][] map = new int[8][7];

        /**
         * 使用编号1表示上下左右都是墙
         */
        for (int i=0;i<7;i++){
            map[0][i] = 1;
            map[7][i] = 1;
        }

        for (int i=0;i<8;i++){
            map[i][0] = 1;
            map[i][6] = 1;
        }

        //设置阻挡墙
        map[3][1] = 1;
        map[3][2] = 1;

        System.out.println("输出地图情况");
        for (int i=0;i<8;i++){
            for (int j=0;j<7;j++){
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }

        getRoute(map,1,1);
        //getRoute2(map,1,1);

        System.out.println("小球标识走过的地图情况");
        for (int i=0;i<8;i++){
            for (int j=0;j<7;j++){
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }


    }

    /**
     * 回溯思想
     * 1、map对象表示地图
     * 2、i和j表示从那个位置出发 （1,1）
     * 3、如果小球能到map[6][5]位置，则说明通路已经找到
     * 4、当map[i][j]为0时，表示该点没有走过，当为1时表示墙，当时2时表示通过可以走，当时3时该点已经走过，
     * 但是走不通。
     * 5、走迷宫时，需要确定一个策略方法，下,右，上，左，如果该点走不通再回溯。
     *
     */
    public static boolean getRoute(int[][] map,int i,int j){
        if (map[6][5] == 2){
            return true;
        }else {
            if (map[i][j] == 0){//如果没有走过该点
                //按照策略走，下，右，上，左
                map[i][j] = 2;
                if (getRoute(map,i+1,j)){ //往下走
                    return true;
                }else if (getRoute(map,i,j+1)){ //往右走
                    return true;
                }else if (getRoute(map,i-1,j)){
                    return true;
                }else if (getRoute(map,i,j-1)){
                    return true;
                }else {
                    //说明该路是死路，走不通
                    map[i][j] = 3;
                    return false;
                }

            }else {//如果map[i][j]不是0，而是1,2,3呢
                return false;
            }
        }

    }

    public static boolean getRoute2(int[][]map,int i,int j){
        if (map[6][5] == 2){
            return true;
        }else{
            if (map[i][j] == 0){//表示该路没有走过
                map[i][j] = 2;//假设该点是可以通走的
                if (getRoute(map,i-1,j)){//上
                    return true;
                }else if (getRoute(map,i,j+1)){//右
                    return true;
                }else if (getRoute(map,i+1,j)){//下
                    return true;
                }else if (getRoute(map,i,j-1)){//左
                    return true;
                }else {
                    //说明该路是死路，走不通过
                    map[i][j] = 3;
                    return false;
                }

            }else {
                //如果map[i][j] 不是0，而是1,2,3
                return false;
            }
        }

    }


}

二冒泡排序

1 生活中的需求：排序

2 解决方案：冒泡排序

（1）思想

水中气泡

（2）流原

从前往后依次比较相邻元素值，把最小或最大的值浮出水面：

轮数 = 元素个数 -1 》for1
第轮比较次数 = 元素个数 - 轮数》 for2

（3）java代码实现

package com.bjpowernode.rabbitmq.config;

import java.util.Arrays;

public class Maopao {
    public static void main(String[] args) {
        int[] arr = {4,5,6,3,2,1};
        int len = arr.length;
        int temp;
        for(int i=0;i<len-1;i++){// 比较轮数 = 元素个数 - 1
            for(int j=0;j<len-i-1;j++){//  每轮比较次数 = 元素个数 - 轮数
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}