数据结构：第三章（一）

最新推荐文章于 2024-06-07 08:25:31 发布
最新推荐文章于 2024-06-07 08:25:31 发布
阅读量102 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49883619/article/details/124391298
版权

视频链接：https://www.bilibili.com/video/BV1HQ4y1d7th

视频范围P87 - P120

目录描述

1.哈希表（线性结构）

散列表(Hash table，也叫哈希表)，是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。

需求：

  1. 添加学生编号时按照从低到高的顺序
  2. 使用链表来实现哈希表，该链表不带表头

学生类：

package hashtable;

public class Student {
    public int id;
    public String name;
    //指向下一个结点的指针
    public Student next;

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

学生链表类：

package hashtable;

public class StudentLinkedList {
    private Student head;

    //添加结点
    //如果添加时
    public void add(Student newStudent){
        //如果添加时是第一个学生对象，则直接复制给第一个结点
        if (head == null){
            head = newStudent;
            return;
        }

        Student temp = head;

        while (true){
            if (temp.next == null){
                break;
            }
            //继续往后查找
            temp = temp.next;
        }

        //追加了新的结点
        temp.next = newStudent;
    }

    //查看数据
    public void list(int no){
        if (head == null){
            System.out.println("第" + no + "链表是空...");
            return;
        }

        Student temp = head;
        while (true){
            System.out.printf("id = %d  name = %s\t",temp.id,temp.name);

            if (temp.next == null){
                break;
            }

            temp = temp.next;
        }
        System.out.println();
    }

    //根据学生的编号查询结点
    public Student findById(int id){
        if (head == null){
            System.out.println("空链表...");
            return null;
        }
        Student temp = head;
        while (true){
            if (temp.id == id){
                break;
            }

            if (temp.next == null){
                temp = null;
                break;
            }
            temp = temp.next;
        }
        return temp;
    }
}

哈希表：

package hashtable;

public class HashTable {
    private StudentLinkedList[] studentLinkedLists;

    private int size;

    public HashTable(int size) {
        this.size = size;
        studentLinkedLists = new StudentLinkedList[size];

        //数组中添加链表对象
        for (int i = 0; i < size; i++) {
            studentLinkedLists[i] = new StudentLinkedList();
        }
    }

    //哈希函数
    public int hashCodes(int sid){
        return sid % size;
    }

    //添加学生
    public void add(Student student){
        //决定了数组中的下标
        int hashVal = hashCodes(student.id);

        //添加到指定的链表中
        studentLinkedLists[hashVal].add(student);

    }

    //查看哈希表中的元素
    public void list(){
        for (int i = 0; i < size; i++) {
            studentLinkedLists[i].list(i);
        }
    }

    //根据学员编号查询
    public void findByStudentId(int sid){
        int hashVal = hashCodes(sid);
        Student students = studentLinkedLists[hashVal].findById(sid);

        if (students != null){
            System.out.printf("在第%d条链表中找到了学员编号是：%d\n",(hashVal + 1),sid);
        }else{
            System.out.println("整个hash表中未找到学员");
        }
    }
}

测试类：

package hashtable;

public class Test {
    public static void main(String[] args) {
        HashTable hashTable = new HashTable(10);

        //添加学员结点
        Student student1 = new Student(1,"张三");
        Student student2 = new Student(2,"张四");
        Student student3 = new Student(2,"张五");
        Student student4 = new Student(3,"张六");
        Student student5 = new Student(3,"张七");

        hashTable.add(student1);
        hashTable.add(student2);
        hashTable.add(student3);
        hashTable.add(student4);
        hashTable.add(student5);

        hashTable.list();

        hashTable.findByStudentId(3);

    }
}

2.树

数组存储方式:

  1. 优点:通过下标方式访问元素，速度快，对于有序数组还可以使用二分查找提高检索速度
  2. 缺点:如果要检索具体某个值，或者插入值会整体移动，效率较低

树存储方式分析:

  1. 能提高数据存储，读取的效率，比如可以使用二叉树既可以保证数据检索速度
  2. 也可以保证数据的插入，删除，修改的速度

2.1 二叉树

二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要
二叉树特点：每个结点最多只能有两棵子树，且有左右之分

在这里插入图片描述
在这里插入图片描述
可以使用前序，中序，后序对二叉树进行遍历

  1. 前序遍历:先输出父结点，再遍历左子树和右子树
  2. 中序遍历:先遍历左子树，再遍历父结点，再遍历右子树
  3. 后序遍历:先遍历左子树，再遍历右子树，最后遍历父结点

结点类：

package tree;

public class Node {

    private int no;
    private String name;
    private Node left;
    private Node right;

    public Node(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Node getLeft() {
        return left;
    }

    public void setLeft(Node left) {
        this.left = left;
    }

    public Node getRight() {
        return right;
    }

    public void setRight(Node right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", left=" + left +
                ", right=" + right +
                '}';
    }

    //前序遍历【遍历所有的】
    public void preSelect(){
        //先输出父结点
        System.out.println(this);

        if (this.left != null){
            this.left.preSelect();
        }

        if (this.right != null){
            this.right.preSelect();
        }
    }

    //中序遍历
    public void infixSelect(){
        //左结点，父结点，右结点
        if (this.left != null){
            this.left.infixSelect();
        }
        System.out.println(this);

        if (this.right != null){
            this.right.infixSelect();
        }

    }

    //后序遍历
    public void postSelcet(){
        if (this.left != null){
            this.left.postSelcet();
        }
        if (this.right != null){
            this.right.postSelcet();
        }
        System.out.println(this);
    }

    //前序遍历查找【根据结点编号】
    public Node preSearch(int no){
        //判断是否是当前结点
        if (this.no == no){
            return this;
        }

        //查询左子结点
        Node lnode = null;
        if (this.left != null){
            lnode = this.left.preSearch(no);
        }

        if (lnode != null){
            return lnode;
        }

        //查询当前结点的右子结点，如果不为空，则继续递归前序查找
        if (this.right != null){
            lnode = this.right.preSearch(no);
        }

        return lnode;
    }

    //中序遍历查找【根据结点编号】
    public Node infixSearch(int no){
        Node node = null;

        //查询左子结点
        if (this.left != null){
            node = this.left.infixSearch(no);
        }

        if (node != null){
            return node;
        }

        //判断是否是当前结点
        if (this.no == no){
            return this;
        }

        //查询当前结点的右子结点，如果不为空，则继续递归前序查找
        if (this.right != null){
            node = this.right.infixSearch(no);
        }
        return node;
    }

    //后序遍历查找【根据结点编号】
    public Node postSearch(int no){
        Node node = null;

        //查询左子结点
        if (this.left != null){
            node = this.left.postSearch(no);
        }

        if (node != null){
            return node;
        }

        //查询当前结点的右子结点，如果不为空，则继续递归前序查找
        if (this.right != null){
            node = this.right.postSearch(no);
        }

        if (node != null){
            return node;
        }

        //判断是否是当前结点
        if (this.no == no){
            return this;
        }

        return node;
    }

    //删除结点两种情况：
    //1.删除的结点是叶子结点
    //2.删除的结点是子树，非叶子结点
    public void delNode(int no){
        //1.当前结点左结点不为空，并且左子结点就是需要删除的结点 this.left = null
        //2.当前结点右结点不为空，并且右子结点就是需要删除的结点，this.right = null
        //3.如果1，2步没有执行，那么需要向左子树进行递归删除
        //4.如果第3步没有执行，那么则向右子树进行递归删除

        if (this.left != null && this.left.no == no){
            this.left = null;
            return;
        }
        if (this.right != null && this.right.no == no){
            this.right = null;
            return;
        }

        if (this.left != null){
            this.left.delNode(no);
        }

        if (this.right != null){
            this.right.delNode(no);
        }

    }
}

二叉树类：

package tree;

public class BinaryTree {
    private Node root;

    public void setRoot(Node node){
        this.root = node;
    }

    //前序遍历
    public void preSelect(){
        if (this.root != null){
            this.root.preSelect();
        }else{
            System.out.println("空二叉树，无法遍历...");
        }
    }

    //中序遍历
    public void infixSelect(){
        if (this.root != null){
            this.root.infixSelect();
        }else{
            System.out.println("空二叉树，无法遍历...");
        }
    }

    //后序遍历
    public void postSelect(){
        if (this.root != null){
            this.root.postSelcet();
        }else{
            System.out.println("空二叉树，无法遍历...");
        }
    }


    //前序查询【根据结点编号】
    public Node preNode(int no){
        if (root != null){
            return root.preSearch(no);
        }else{
            System.out.println("空二叉树，无法遍历...");
            return null;
        }
    }

    //中序查询【根据结点编号】
    public Node infixNode(int no){
        if (root != null){
            return root.infixSearch(no);
        }else{
            System.out.println("空二叉树，无法遍历...");
            return null;
        }
    }

    //中序查询【根据结点编号】
    public Node postNode(int no){
        if (root != null){
            return root.postSearch(no);
        }else{
            System.out.println("空二叉树，无法遍历...");
            return null;
        }
    }

    //删除结点
    public void delNode(int no){
        if (root != null){
            if (root.getNo() == no){
                root = null;
            }else{
                root.delNode(no);
            }
        }else {
            System.out.println("空二叉树，无法删除...");
        }
    }
}

测试类：

package tree;

public class Test {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();

        Node root = new Node(1,"孙尚香");
        Node node2 = new Node(2,"夏侯惇");
        Node node3 = new Node(3,"貂蝉");
        Node node4 = new Node(4,"吕布");
        Node node5 = new Node(5,"虞姬");
        Node node6 = new Node(6,"王昭君");

        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setRight(node6);

        binaryTree.setRoot(root);

        //删除结点
        binaryTree.delNode(5);

        binaryTree.preSelect();
        System.out.println("-----------------------");
        binaryTree.infixSelect();
        System.out.println("-----------------------");
        binaryTree.postSelect();

        //前序查找【根据编号】
        Node node = binaryTree.preNode(5);
        if (node != null){
            System.out.printf("信息为：id = %d name = %s",node.getNo(),node.getName());
        }else {
            System.out.println("没有找到结点");
        }

    }
}

结点树：
在这里插入图片描述

运行结果：

在这里插入图片描述

2.2 顺序存储二叉树

二叉树的顺序存储就是用一组连续的存储单元（数组)存放二叉树中的结点元素，一般按照二叉树结点自上向下、自左向右的顺序存储。

  1. 顺序二叉树通常只考虑完全二叉树
  2. 第n个元素的左子结点为 2 ∗ n + 1 2*n+1 2∗n+1
  3. 第n个元素的右子结点为 2 ∗ n + 2 2*n+2 2∗n+2
  4. 第n个元素的父结点为 （ n − 1 ） / 2 （n-1）/2 （n−1）/2
package tree;

public class ArrayBinaryTree {
    private int[] arrays;

    public ArrayBinaryTree(int[] arrays) {
        this.arrays = arrays;
    }

    //前序遍历顺序存储二叉树
    public void preSelect(int index){
        if (this.arrays == null || arrays.length == 0){
            System.out.println("存储数组为空....");
        }

        //向左递归
        if ((index * 2 + 1) < arrays.length){
            preSelect(index * 2 + 1);
        }

        //向右递归
        if ((index * 2 + 2) < arrays.length){
            preSelect(index * 2 + 2);
        }
    }
}

2.3 线索化二叉树

  1. 在二叉树的结点上加上线索的二叉树称为线索二叉树，对二叉树以某种遍历方式(如先序、中序、后序等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化
  2. 对于n个结点的二叉树，在二叉链存储结构中有n+1个空链域，利用这些空链域存放在某种遍历次序下该结点的前驱结点和后继结点的指针，这些指针称为线索，加上线索的二叉树称为线索二叉树。
  3. 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种。
  4. 一个结点的前一个结点，称之为前驱结点，一个结点后一个结点称之为后继结点

在这里插入图片描述
结点类：

package clue;

public class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

    //0表示指向的是左子树
    //1表示指向的前驱
    private int noLeft;

    //0表示指向的是右子树
    //1表示指向的后继
    private int noRight;

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    public int getNoLeft() {
        return noLeft;
    }

    public void setNoLeft(int noLeft) {
        this.noLeft = noLeft;
    }

    public int getNoRight() {
        return noRight;
    }

    public void setNoRight(int noRight) {
        this.noRight = noRight;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    //删除结点
    //删除的可能是一个叶子结点，也可能是非叶子结点
    public void delNode(int no){
        //1.如果当前结点左结点不为空，并且左子结点正好是要删除的，this.left = null;
        //2.如果当前结点右结点不为空，并且右子结点正好是要删除的，this.right = null;
        //3. 1和2都没有执行，左子树递归
        //4.3没有执行，向右递归找右子树

        if (this.left != null && this.left.no == no){
            this.left = null;
            return;
        }

        if (this.right != null && this.right.no == no){
            this.right = null;
            return;
        }

        //判断，防止异常
        if (this.left != null){
            this.left.delNode(no);
        }

        if (this.right != null){
            this.right.delNode(no);
        }
    }

    //前序遍历所有
    public void preSelect(){
        System.out.println(this);
        if (this.left != null){
            this.left.preSelect();
        }

        if (this.right != null){
            this.right.preSelect();
        }
    }

    //前序遍历【根据编号查找】
    public HeroNode preSelect(int no){
        if (this.no == no){
            return this;
        }

        HeroNode temp = null;

        //往左递归
        if (this.left != null){
            temp = this.left.preSelect(no);
        }

        if (temp != null){
            return temp;
        }

        //往右递归
        if (this.right != null){
            temp = this.right.preSelect(no);
        }

        return temp;
    }
}

线索化二叉链表树：

package clue;

public class ClueBianryTree {
    private HeroNode root;

    //当前结点前驱结点指针
    private HeroNode pre;

    public void setRoot(HeroNode root) {
        this.root = root;
    }

    //调用这个方法等于把非线索化二叉树转换为线索化二叉树
    public void clueNode(){
        this.clueNode(root);
    }

    //把普通二叉树转换为线索化二叉树
    public void clueNode(HeroNode node){
        //判断是否可以线索化当前结点
        if (node == null){
            return;
        }

        //先线索化左子树
        clueNode(node.getLeft());

        //处理当前结点前驱
        if (node.getLeft() == null){
            node.setLeft(pre);
            node.setNoLeft(1);
        }

        //处理当前结点后继
        if (pre != null && pre.getRight() == null){
            pre.setRight(node);
            pre.setNoRight(1);
        }

        //保证处理完一个结点后，就需要让当前结点作为下一个结点的前驱
        pre = node;

        //线索化右子树
        clueNode(node.getRight());
    }

    //遍历线索化的二叉树
    public void clueList(){
        //临时结点
        HeroNode node = root;

        while (node != null){

            //向左查询头结点
            while (node.getNoLeft() == 0){
                node = node.getLeft();
            }

            System.out.println(node);

            //查找后继结点
            while (node.getNoRight() == 1){
                node = node.getRight();
                System.out.println(node);
            }

            node = node.getRight();
        }
    }
}

测试类：

package clue;

public class TestApp {
    public static void main(String[] args) {

        HeroNode root = new HeroNode(1,"吕布");
        HeroNode node2 = new HeroNode(3,"貂蝉");
        HeroNode node3 = new HeroNode(6,"曹操");
        HeroNode node4 = new HeroNode(8,"刘备");
        HeroNode node5 = new HeroNode(10,"关羽");
        HeroNode node6 = new HeroNode(14,"张飞");

        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

        ClueBianryTree clueBianryTree = new ClueBianryTree();
        clueBianryTree.setRoot(root);

        //把普通二叉树线索化为线索二叉树
        clueBianryTree.clueNode();

        //获取10的前驱和后继
        HeroNode left = node5.getLeft();
        HeroNode right = node5.getRight();
        System.out.println("10号结点前驱是：" + left.getNo() + " 后继是：" + right.getNo());

        //把线索化二叉树按照中序遍历查询
        clueBianryTree.clueList();
    }
}

运行结果：

在这里插入图片描述

计算机量子狗
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——第一章：绪论
Ajun的IT博客
10-26 2988
学习目标： 了解并理解数据，数据元素，数据结构，逻辑结构，存储结构，算法及算法设计-分析-时间复杂度等知识点。 1、绪论 一、数据结构的概念及其内容 数据结构是带有结构的数据元素的集合，其中的结构是指数据元素之间的相互关系，即数据的组织形式。 数据（data）：描述客观事物的数，字符以及能输入计算机中并被计算机处理的符号的集合。如：整数，实数，字符串，当...
《数据结构》 李春葆 第一章-绪论
lindi256270的博客
02-14 1619
《数据结构》 李春葆 第一章-绪论1 什么是数据结构1.1 数据结构的定义1.2 逻辑结构1.3 存储结构1.4 逻辑运算1.5 数据类型和抽象数据类型2.算法及其描述3.算法分析1.引入库2.读入数据4.数据结构+算法=程序 1 什么是数据结构 数据元素以及数据元素之间的关系，数据元素=数据+结构 1.1 数据结构的定义   数据(data)：描述客观事物的数字和字符的集合(例如，2班全体学生的信息集合，包括学号、姓名、性别等，如下表格) 学号 姓名 性别 01 张三 男 02 李四
单向链表的增删
My Code Library
05-21 60
using System ; public class LinkedList { //嵌套类表示单个节点； private class Node { public Node (object values) { item=values ; } public object item; //数据域； public Node next;//指针域...
数据结构：八种数据结构大全
緑水長流*z
07-29 19万+
数据结构 1.1 数据结构概述 数据结构是计算机存储、组织数据的方式；通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能；常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等； 1.2 数据结构的分类 1.2.1 排列方式 1）集合 集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系； 2）线性结构 线性
数据结构总结——第一章
weixin_64300656的博客
06-23 1967
数据结构第一章概要 总结
数据结构笔记（王道考研） 第一章：绪论
zimuzi2019的博客
08-09 4050
数据结构笔记（王道考研） 第一章：绪论
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
chongyang_的博客
11-07 25万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 39万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构——第一章 绪论习题
sunyanxian的博客
11-29 3804
目录写在前面知识点导图严蔚敏版习题王曙燕版习题 写在前面 该习题答案非标准答案，正确不保证，如有错误望指正。 知识点导图 严蔚敏版习题 一、单项选择题（部分） 2、与数据元素本身的形式、内容、相对位置、个数无关的是数据的（C、逻辑结构） 逻辑结构是从具体问题抽象出来的数学模型 ，从逻辑关系上描述数据，它与数据的存储无关，也就是说与数据本身的具体形式、内容、相对位置、个数无关。 5、算法的时间复杂度取决于（D、问题的规模和待处理数据的初态） 算法的时间复杂度不仅与问题的规模有关，还与问题的其他元素有关。如某
软考——软件设计师：第四章：数据结构&算法分析与设计考点总结（完整篇）
胜天半子祁同伟
08-19 3万+
软考——软件设计师：第四章：数据结构&算法分析与设计考点总结（完整篇）
数据结构：第三章 栈和队列.ppt
06-10
数据结构：第三章 栈和队列.ppt
数据结构：第3章 栈和队列.pdf
06-12
数据结构：第3章 栈和队列.pdf
数据结构：第3章 栈和队列.ppt
06-12
数据结构：第3章 栈和队列.ppt
算法与数据结构：第3章线性表.ppt
05-27
算法与数据结构：第3章线性表.ppt
java环境部署
JiuMeilove的博客
06-04 390
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
finereport 9.0 Tomcat 集群-来自帆软
最新发布
chenmingfa110的博客
06-07 568
APACHE_HOME ％为你的安装目录。对于每个新来的session，Apache按照节点配置中的lbfactor比重选择访问节点，如果某节点node1不能访问，则寻找下一可访问节点，并且将此node1就在该访问session的访问黑名单中，以后该session的访问直接不考虑node1，即使node1又可以访问了。注：由于这里三个tomcat全在一台机器上，所以需要修改三种类型的端口号，如果是在不同的机器上，则只需要修改AJP13的connector的port，其他端口号不需要修改。
java中Overload和Override的区别
codedadi的博客
06-04 577
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
Spring异步任务@Async的默认线程池执行器是如何初始化的
简放视野的专栏
06-03 640
Spring异步任务@Async的默认线程池执行器，是从哪里来？是如何初始化的？ 【结论】异步任务@Async的默认线程池执行器是通过TaskExecutionAutoConfiguration#applicationTaskExecutor自动注入的。
拼图小游戏
lazy_girl_666的博客
06-03 720
把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制。
数据结构与算法第三章笔记
04-04
当然，我可以给你介绍一下数据结构与算法第三章的笔记。第三章主要讲解了栈和队列这两种常用的数据结构。 1. 栈（Stack）是一种后进先出（LIFO）的数据结构。它的特点是只能在栈顶进行插入和删除操作。栈的基本操作包括入栈（push）、出栈（pop）、获取栈顶元素（top）和判断栈是否为空（empty）等。 2. 队列（Queue）是一种先进先出（FIFO）的数据结构。它的特点是只能在队尾进行插入操作，在队头进行删除操作。队列的基本操作包括入队（enqueue）、出队（dequeue）、获取队头元素（front）和判断队列是否为空（empty）等。 3. 栈和队列都可以使用数组或链表来实现。使用数组实现的栈和队列称为顺序栈和顺序队列，而使用链表实现的栈和队列称为链式栈和链式队列。 4. 栈和队列在实际应用中有广泛的应用。例如，栈可以用于实现函数调用的递归、表达式求值、括号匹配等；队列可以用于实现广度优先搜索、任务调度等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值