数据结构与算法知识总结三（用Java代码实现）

最新推荐文章于 2022-09-15 16:00:24 发布
最新推荐文章于 2022-09-15 16:00:24 发布
阅读量162 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52781902/article/details/126684416
版权

6. 递归

6.1 介绍

简单的说：递归就是方法自己调用自己，每次调用时传入不同的变量，递归有助于编程者解决复杂的问题。同时可以让代码变得简洁。

image-20220903192844309

递归能解决什么样的问题呢

  • 各种数学问题如: 8皇后问题 , 汉诺塔, 阶乘问题, 迷宫问题, 球和篮子的问题(google编程大赛)
  • 各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等.
  • 将用栈解决的问题—>递归代码比较简洁

递归需要遵守的重要规则

  • 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)

  • 方法的局部变量是独立的，不会相互影响，比如n变量

  • 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据

  • 递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError

  • 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就

    执行完毕

6.2 递归—迷宫问题

6.2.1 概述

说明：

  • 小球得到的路径，和程序员设置的找路策略有关即：找路的上下左右的顺序相关
  • 再得到小球路径时，可以先使用(下右上左)，再改成(上右下左)，看看路径是不是有变化
  • 测试回溯现象
  • 思考**: **如何求出最短路径?
6.2.2 代码实现
public class Maze {
    public static void main(String[] args) {
        // 先创建一个二维数组，模拟迷宫
        int[][] map = new int[8][7];

        // 使用1表示墙，上下左右边界全部置为1
        for (int i = 0; i < map.length; i++) {
            if (i == 0 || i == map.length - 1) {
                Arrays.fill(map[i], 1);
            } else {
                map[i][0] = 1;
                map[i][map[i].length - 1] = 1;
            }
        }

        // 设置挡板，1表示
        map[3][1] = 1;
        map[3][2] = 1;

        // 打印地图
        System.out.println("原本地图的情况");
        printMap(map);

        // 使用递归回溯
        setWay(map, 1, 1);
        System.out.println("小球走过并且标识的地图的情况：");
        printMap(map);
    }

    /**
     * 终点为右下角位置
     * 当map[i][j]为0时，表示没有走过
     * 当map[i][j]为1时，表示墙
     * 当map[i][j]为2时，表示通路可以走
     * 当map[i][j]为3时，表示该点走不通
     * 在走迷宫时，需要确定一个测略（方法） 下 -> 右 -> 上 -> 左 ， 如果该点走不通，再回溯
     *
     * @param map 地图
     * @param i   出发点x坐标
     * @param j   出发点y坐标
     * @return true or false
     */
    public static boolean setWay(int[][] map, int i, int j) {
        // 递归出口
        int row = map.length - 2;
        int col = map[0].length - 2;
        if (map[row][col] == 2) {
            // 找到出口
            return true;
        } else {
            // 说明当前这个点还没有走过
            if (map[i][j] == 0) {
                // 按照策略 下 -> 右 -> 上 -> 左
                // 假定该点是可以走通的
                map[i][j] = 2;

                if (setWay(map, i + 1, j)) {
                    // 向下走
                    return true;
                } else if (setWay(map, i, j + 1)) {
                    // 右
                    return true;
                } else if (setWay(map, i - 1, j)) {
                    // 上
                    return true;
                } else if (setWay(map, i, j - 1)) {
                    // 左
                    return true;
                } else {
                    // 说明该点走不通，是死路，不过既然上下左右都走不通，那么这点不会经过的
                    map[i][j] = 3;
                    return false;
                }
            } else {
                // 说明该节点，可能是1 2 3，2的出现是因为迷宫问题不会走重复路，不然会绕圈
                return false;
            }
        }
    }

    /**
     * 打印地图
     *
     * @param map 二维地图
     */
    public static void printMap(int[][] map) {
        // 打印地图
        for (int[] ints : map) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
    }
}

输出结果：

原本地图的情况
1 1 1 1 1 1 1 
1 0 0 0 0 0 1 
1 0 0 0 0 0 1 
1 1 1 0 0 0 1 
1 0 0 0 0 0 1 
1 0 0 0 0 0 1 
1 0 0 0 0 0 1 
1 1 1 1 1 1 1 
小球走过并且标识的地图的情况：
1 1 1 1 1 1 1 
1 2 0 0 0 0 1 
1 2 2 2 0 0 1 
1 1 1 2 0 0 1 
1 0 0 2 0 0 1 
1 0 0 2 0 0 1 
1 0 0 2 2 2 1 
1 1 1 1 1 1 1

6.3 递归—八皇后问题

6.3.1 概述

image-20220903214914903

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国

际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

八皇后问题算法思路分析

暴力解法（穷举解法）：

  1. 第一个皇后先放第一行第一列
  2. 第二个皇后放在第二行第一列、然后判断是否OK， 如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
  3. 继续第三个皇后，还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解
  4. 当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到.
  5. 然后回头继续第一个皇后放第二列，后面继续循环执行 1,2,3,4的步骤

说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题：

arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3} //对应arr 下标 表示第几行，即第几个皇后，arr[i] = val , val 表示第i+1个皇后，放在第i+1行的第val+1列

6.3.2 代码实现
public class Queen8 {
    /**
     * 定义一个max表示有多少个皇后
     */
    final static int MAX = 8;

    /**
     * 定义一个Array数组，保存皇后放置位置的结果，比如array = {0,4,7,5,2,6,1,3}
     */
    static int[] array = new int[MAX];

    /**
     * 如果是多线程，使用原子类能确保得到最终的情况数
     */
    static AtomicInteger count = new AtomicInteger(0);

    /**
     * 统计判断的次数
     */
    static AtomicInteger judgeCount = new AtomicInteger(0);

    public static void main(String[] args) {
        check(0);
        System.out.println("总共有【" + count + "】情况");
        System.out.println("总共有【" + judgeCount + "】次判断冲突的次数");
    }

    /**
     * 放置第n + 1个皇后，递归
     *
     * @param n 第 n + 1个皇后
     */
    public static void check(int n) {
        // 递归出口 说明8个皇后已经放好
        if (n == MAX) {
            print();
            // 打印一次 就代表一种解法
            count.getAndIncrement();
            return;
        }

        for (int i = 0; i < MAX; i++) {
            // 把第n个皇后放置在第i列
            array[n] = i;
            // 判断是否冲突
            if (judge(n)) {
                // 不冲突的话 递归
                check(n + 1);
            }
            // 冲突的话 将第n个皇后移动一列
        }
    }

    /**
     * 判断第 n + 1个皇后是否和前面皇后冲突
     *
     * @param n 表示第 n + 1个皇后
     * @return 是否可以摆放
     */
    public static boolean judge(int n) {
        judgeCount.getAndIncrement();
        for (int i = 0; i < n; i++) {
            // 代表不能放在同一列 和同一斜线上（斜率相同）
            if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
                return false;
            }
        }
        return true;
    }

    /**
     * 打印皇后的位置
     */
    public static void print() {
        for (int arr : array) {
            System.out.print(arr + " ");
        }
        System.out.println();
    }
}

输出结果：

0 4 7 5 2 6 1 3 
0 5 7 2 6 3 1 4 
0 6 3 5 7 1 4 2 
0 6 4 7 1 3 5 2 
1 3 5 7 2 0 6 4 
1 4 6 0 2 7 5 3 
1 4 6 3 0 7 5 2 
1 5 0 6 3 7 2 4 
1 5 7 2 0 3 6 4 
1 6 2 5 7 4 0 3 
1 6 4 7 0 3 5 2 
1 7 5 0 2 4 6 3 
2 0 6 4 7 1 3 5 
2 4 1 7 0 6 3 5 
2 4 1 7 5 3 6 0 
2 4 6 0 3 1 7 5 
2 4 7 3 0 6 1 5 
2 5 1 4 7 0 6 3 
2 5 1 6 0 3 7 4 
2 5 1 6 4 0 7 3 
2 5 3 0 7 4 6 1 
2 5 3 1 7 4 6 0 
2 5 7 0 3 6 4 1 
2 5 7 0 4 6 1 3 
2 5 7 1 3 0 6 4 
2 6 1 7 4 0 3 5 
2 6 1 7 5 3 0 4 
2 7 3 6 0 5 1 4 
3 0 4 7 1 6 2 5 
3 0 4 7 5 2 6 1 
3 1 4 7 5 0 2 6 
3 1 6 2 5 7 0 4 
3 1 6 2 5 7 4 0 
3 1 6 4 0 7 5 2 
3 1 7 4 6 0 2 5 
3 1 7 5 0 2 4 6 
3 5 0 4 1 7 2 6 
3 5 7 1 6 0 2 4 
3 5 7 2 0 6 4 1 
3 6 0 7 4 1 5 2 
3 6 2 7 1 4 0 5 
3 6 4 1 5 0 2 7 
3 6 4 2 0 5 7 1 
3 7 0 2 5 1 6 4 
3 7 0 4 6 1 5 2 
3 7 4 2 0 6 1 5 
4 0 3 5 7 1 6 2 
4 0 7 3 1 6 2 5 
4 0 7 5 2 6 1 3 
4 1 3 5 7 2 0 6 
4 1 3 6 2 7 5 0 
4 1 5 0 6 3 7 2 
4 1 7 0 3 6 2 5 
4 2 0 5 7 1 3 6 
4 2 0 6 1 7 5 3 
4 2 7 3 6 0 5 1 
4 6 0 2 7 5 3 1 
4 6 0 3 1 7 5 2 
4 6 1 3 7 0 2 5 
4 6 1 5 2 0 3 7 
4 6 1 5 2 0 7 3 
4 6 3 0 2 7 5 1 
4 7 3 0 2 5 1 6 
4 7 3 0 6 1 5 2 
5 0 4 1 7 2 6 3 
5 1 6 0 2 4 7 3 
5 1 6 0 3 7 4 2 
5 2 0 6 4 7 1 3 
5 2 0 7 3 1 6 4 
5 2 0 7 4 1 3 6 
5 2 4 6 0 3 1 7 
5 2 4 7 0 3 1 6 
5 2 6 1 3 7 0 4 
5 2 6 1 7 4 0 3 
5 2 6 3 0 7 1 4 
5 3 0 4 7 1 6 2 
5 3 1 7 4 6 0 2 
5 3 6 0 2 4 1 7 
5 3 6 0 7 1 4 2 
5 7 1 3 0 6 4 2 
6 0 2 7 5 3 1 4 
6 1 3 0 7 4 2 5 
6 1 5 2 0 3 7 4 
6 2 0 5 7 4 1 3 
6 2 7 1 4 0 5 3 
6 3 1 4 7 0 2 5 
6 3 1 7 5 0 2 4 
6 4 2 0 5 7 1 3 
7 1 3 0 6 4 2 5 
7 1 4 2 0 6 3 5 
7 2 0 5 1 4 6 3 
7 3 0 2 5 1 6 4 
总共有【92】情况
总共有【15720】次判断冲突的次数

7. 哈希表

7.1 介绍

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中

一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

image-20220903222606728

结构

哈希表：

  • 数组 + 链表
  • 数组 + 二叉树
  • 数组+链表+红黑树

7.2 实例

需求

  • 有一个公司，当有新的员工来报道时,要求将该员工的信息加入(id、性别、年龄、住址……)，当输入该员工的id时，要求查找到该员工

    的所有信息

  • 要求：不使用数据库，尽量节省内存，速度越快越好 => 哈希表(散列)

散列函数分析

  • 可以把每个字符的ASCII对应的数字相加作为下标，比如abc = (a-96) + (b-96) + (c-96)，a的ASCII是97；这种方式的缺点就是哈希值很

    容易重复，比如bbb、abc、cba

  • 也可以使用幂的连乘，比如abc，1*27^0+2*27^1+3*27^2，解决越界问题可以使用大数运算，java里的BigInteger

public int hash3(String key) {
    BigInteger hashvalue = new BigInteger("0");
    BigInteger pow27 = new BigInteger("1");

    for (int i = 0; i < key.length(); i++) {
        // 比如abc,1*27^0+2*27^1+3*27^2
        int letter = key.charAt(i) - 96;
        // 把letter用bigint包装起来
        BigInteger bigLetter = new BigInteger(letter + "");
        hashvalue = hashvalue.add(bigLetter.multiply(pow27));
        pow27 = pow27.multiply(new BigInteger(27 + ""));
    }
    return hashvalue.mod(new BigInteger(arrays.length + "")).intValue();
}

用户实体类

@Data
public class Employee {
    private int id;

    private String name;

    private Employee next;

    public Employee(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
}

雇员链表EmployeeLinkedList类

public class EmployeeLinkedList {
    /**
     * 头指针，指向第一个Emp，因此我们这个链表的head是直接指向第一个Emp，默认为null
     */
    private Employee head;
    /**
     * 尾指针，指向最后一个Emp
     */
    private Employee tail;

    /**
     * 假定当添加雇员的时候，id是自增长的，直接加入到链表的最后就行
     */
    public void add(Employee employee) {
        // 如果是第一个雇员
        if (head == null) {
            head = employee;
            tail = head;
        } else {
            tail.setNext(employee);
            tail = employee;
        }
    }

    /**
     * 显示员工
     */
    public void list(int i) {
        if (head == null) {
            System.out.println("第" + i + "条链表为空");
            return;
        } else {
            System.out.print("第" + i + "条链表信息为：");
            Employee temp = head;
            while (temp != null) {
                System.out.printf("=> id = %d, name = %s\t", temp.getId(), temp.getName());
                temp = temp.getNext();
            }
            System.out.println();
        }
    }

    /**
     * 删除员工
     */
    public void delete(int id) {
        // 判断链表是否为空
        if (head == null) {
            System.out.println("该元素不存在");
            return;
        }
        if (head.getId() == id) {
            head = head.getNext();
            return;
        }
        Employee temp = head;
        while (temp.getNext() != null) {
            if (temp.getNext().getId() == id) {
                temp.setNext(temp.getNext().getNext());
            }
            temp = temp.getNext();
        }
    }

    /**
     * 查找员工
     */
    public Employee find(int id) {
        // 判断链表是否为空
        if (head == null) {
            System.out.println("该元素不存在");
            return null;
        }
        Employee temp = head;
        while (temp != null) {
            if (temp.getId() == id) {
                return temp;
            }
            temp = temp.getNext();
        }
        System.out.println("该元素不存在");
        return null;
    }
}

哈希表MyHashTable类

public class MyHashTable {

    private EmployeeLinkedList[] employeeLinkedListArray;

    private int size;

    public MyHashTable(int size) {
        this.size = size;
        employeeLinkedListArray = new EmployeeLinkedList[size];
        // 分别初始化每个链表
        for (int i = 0; i < size; i++) {
            employeeLinkedListArray[i] = new EmployeeLinkedList();
        }
    }

    /**
     * 编写散列函数，使用一个简单取模法
     *
     * @param id 员工id
     * @return 索引
     */
    public int hashFun(int id) {
        return id % size;
    }

    /**
     * 新增员工
     *
     * @param employee 员工实体
     */
    public void add(Employee employee) {
        int index = hashFun(employee.getId());
        employeeLinkedListArray[index].add(employee);
    }

    /**
     * 删除员工
     *
     * @param id 员工id
     */
    public void delete(int id) {
        int index = hashFun(id);
        employeeLinkedListArray[index].delete(id);
    }

    /**
     * 查找员工
     *
     * @param id 员工id
     * @return 员工
     */
    public Employee find(int id) {
        int index = hashFun(id);
        return employeeLinkedListArray[index].find(id);
    }

    /**
     * 打印链表
     */
    public void list() {
        for (int i = 0; i < size; i++) {
            employeeLinkedListArray[i].list(i);
        }
    }
}

Ambition0823
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java实现数据结构
11-10
包含链表、 栈、 队列、优先级队列、哈希表，绝对原创总结！
Java知识+算法+数据结构
最新发布
04-08
这个资源无疑是一个宝藏，它提供了海量...他们可以在这里分享自己的解题思路、代码实现和心得体会，与其他同学互相学习、共同进步。这种氛围不仅能够激发学生的学习热情，还能让他们在不断的交流中拓展视野、提升自我。
数据结构Java实现01----算法概述
weixin_34318326的博客
08-12 147
  【声明】  欢迎转载，但请保留文章原始出处→_→  生命壹号：http://www.cnblogs.com/smyhvae/ 文章来源：http://www.cnblogs.com/smyhvae/p/4724692.html   【正文】      一、数据结构涵盖的内容：   二、算法的基本概念： 1、算法的概念： Algorithm,是对特定问题求解...
数据结构与基本算法(Java语言实现)
CXY_Stole的博客
07-07 976
未完待续，有空实时补充
【图解算法数据结构】数据结构篇 + Java代码实现
热门推荐
知不足而奋进，望远山而前行
09-15 2万+
本题使用有限状态自动机。根据字符类型和合法数值的特点，先定义状态，再画出状态转移图，最后编写代码即可。
数据结构——java实现
clear-ninghongkang的博客
05-23 296
用数组模拟队列 package com.clear.queue; import java.util.Scanner; /** * 用数组模拟队列 */ public class CircleArrayQueueDemo { public static void main(String[] args) { // 测试 System.out.println("—————测试数组模拟环形数组—————"); CircleArrayQueue qu
Java知识点总结，面试必备，java基础、java集合、JVM、Java并发、数据结构与算法、LeetCode
01-14
Java知识点总结，面试必备，java基础、java集合、JVM、Java并发、数据结构与算法、LeetCode、剑指offer、计算机网络、设计模式、MySQL、Redis.zip
数据结构与算法程序示例。常用算法思想总结归档。使知识体系化.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
[持续更新]leetcode按算法与数据结构类型总结+java面试知识+互联网公司JAVA笔试题总结.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
leetcode按算法与数据结构类型总结+java面试知识+互联网公司JAVA笔试题总结.zip
10-03
leetcode按算法与数据结构类型总结+java面试知识+互联网公司JAVA笔试题总结
数据结构Java版源代码
05-27
绝对经典，建议与书籍和源代码相结合，，，，，，，，，，
JAVA语言版_数据结构与算法（内含源代码）
07-31
JAVA语言版_数据结构与算法（内含源代码）
Java数据结构和算法(第二版)+随书源代码+applet小程序
09-14
适用于想让java再上一层境界的人，书中从简入繁，并且附带applet小程序，让学习者一目了然，形象生动，比如说冒泡排序，一步步执行，可以看到每一次比较的图像结果，不用抽象的文字描述，让学习者更易掌握
java数据结构源码
06-25
java实现数据结构，数组，链表，二叉树，图以及各种高级排序
Java数据结构和算法（第二版）源代码
08-24
包含Java数据结构和算法（第二版）书中每章节源代码
数据结构-java实现
Wade__Hao的博客
08-17 585
数据结构 1. 概述 1.1 什么是数据结构 官方：数据结构是一门研究非数值计算的程序设计问题中的操作对象，以及他们之间的关系和操作等相关问题的学科； 数据结构就是把数据元素按照一定的关系组织起来的集合，用来组织和存储数据 1.2 数据结构分类 逻辑结构 集合机构 线性结构 树形结构 图形结构 物理结构：逻辑结构在计算机中真正的表示方式 顺序存储结构 链式存储结构 1.3 什么是算法 算法是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法解决问题
「Java数据结构和算法」手撕快速、归并、基数排序，图解解析 + 代码实现。
yzh2776680982的博客
09-03 1183
以上面的数组为例分析快速排序。首先要传入三个值，数组arr[]，最左边下标left，最右边下标right。然后将根据左右的下标值计算出中间值mid。我们要做的就是将左边的值大于mid的放到右边，将右边小于mid的值放到左边。左右两边分别单独循环，左边找到比mid大的数，右边找到比mid小的数。两边分别找到符合条件的数后，进行交换。然后继续比较并交换，此刻l和mid都指向3，r指向5。▶首先实现合并intt=0;//数组temp的下标//判断。...
java数据结构知识_【java算法与数据结构】必备知识点汇总
weixin_30356285的博客
02-16 351
码字不易，喜欢请点赞！！！1.数据结构基础2.线性表(顺序存储、链式存储)元素之间是有顺序的：第一个元素无前驱，最后一个元素无后继，其他元素都有前驱和后继顺序存储结构：用一段地址连续的存储单元一次存储线性表的数据元素(存取时间复杂度为O(1)，插入或删除时间复杂度为O(N)，适合数据量不大并且存取操作多的数据)优缺点：链式结构：元素信息+后继元素的地址(读取、插入、删除：时间复杂度O(N))头指针...
数据结构与算法知识总结一（用Java代码实现）
木子Teng的博客
09-03 251
数据结构与算法知识总结一（用Java代码实现）
数据结构实训仓库货物管理代码java
09-28
总结起来，数据结构实训仓库货物管理代码Java通过使用链表、栈和数组等数据结构，实现了对仓库货物的增加、删除、查询和修改等功能。该代码不仅具有良好的可读性和可维护性，还具备一定的灵活性和扩展性，方便后续的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ambition0823

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值