数据结构与算法--004-队列链表实现--Java

最新推荐文章于 2022-05-22 15:10:09 发布
最新推荐文章于 2022-05-22 15:10:09 发布
阅读量307 收藏
点赞数 1
分类专栏： 数据结构与算法[体系] 文章标签： 链表 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44236958/article/details/109608570
版权

链表

目录

链表是有序的列表， 但是它在内存中是存储如下

  1. 链表是以节点的方式来储存.链式储存
  2. 每个节点包含data 域， next 域： 指向下一个节点
  3. 如图： 发现链表的各个节点不一定是连续存储.
  4. 链表分带头节点的链表和没有头节点的链表， 根据实际的需求来确定

单链表(带头结点) 逻辑结构示意图如下

在这里插入图片描述

在这里插入图片描述

单链表的应用实例

第一种方法在添加英雄时， 直接添加到链表的尾部

不考虑顺序编号

  1. 找的当前链表的最后节点
  2. 将最后这个节点的next指向新的节点
  3. 将最后这个节点的next指向新的节点 temp.next = heroNode;
  public void add(HeroNode heroNode) {
        //头节点不能动,需要一个辅助遍历temp
        HeroNode temp = head;
        //遍历链表到最后
        while (true) {
            if (temp.next == null) {
                break;
            }
            //如果没有找的,将temp后移
            temp = temp.next;
        }
        //当退出while循环,temp就指向链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

在这里插入图片描述

第二种方式在添加英雄时，根据排名将英雄插入到指定位置

  1. 因为头节点不能动，因此我们仍然通过一个辅助指针(变量)
  2. 因为单链表,我们找的temp是位于添加位置的前一个节点,否则插入失败
  3. temp = temp.next;
  4. 插入到链表中, temp的后面
  5. heroNode.next = temp.next;
  6. temp.next = heroNode;
       HeroNode temp = head;
        boolean flag = false; // flag标志添加的编号是否存在，默认为false
        while (true) {
            //说明已经在链表最后了
            if (temp.next == null) {
                break;
            }
            位置找到，就在temp的后面插入
            if (temp.next.no > heroNode.no) {
                break;
                //说明希望添加的heroNode的编号已然存在
            } else if (temp.next.no == heroNode.no) {
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }
        if (false) {
            System.out.println(heroNode.no + "该编号存在");
        } else {
            //插入到链表中, temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

在这里插入图片描述

修改节点的信息

  • 根据 newHeroNode 的 no 来修改即可
  • 找到需要修改的节点, 根据no编号定义一个辅助变量
  • 找到该节点
  • 根据flag 判断是否找到要修改的节点
  • temp.name = newHeroNode.name;
//修改节点
    public void update(HeroNode heroNode) {
        if (head.next == null) {
            System.out.println("此节点为空");
            return;
        }
        //找到要修改的节点,根据no修改
        //定义一个辅助变量
        HeroNode temp = head;
        boolean flag = false;//表示是否找到该节点
        while (true) {
            if (temp == null) {
                break;//遍历完毕
            }
            if (temp.no == heroNode.no) {
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag判断是否是要修改的节点
        if (flag) {
            temp.name = heroNode.name;
        } else {
            System.out.println("没有找到要修改的编号" + heroNode.no);
        }
    }

在这里插入图片描述

删除节点

  • head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
  • 说明我们在比较时，是temp.next.no 和 需要删除的节点的no比较
  • 遍历链表,找到对应的链表
  • temp.next = temp.next.next;
 1.head不能动,需要一个辅助变量temp 辅助节点找到要删除的节点
    1.我们在比较的时候只需要找到temp.next.no 和要需要的no作比较
     */
    public void del(int no) {
        //找到要修改的节点,根据no修改
        //定义一个辅助变量
        HeroNode temp = head;
        boolean flag = false;// 标志是否找到待删除节点的
        while (true) {
            if (temp.next == null) { //已经到链表的最后
                break;//遍历完毕
            }
            if (temp.next.no == no) {
                //找到的待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.println("要删除的节点不在" + no);
        }
    }

在这里插入图片描述

获取到单链表的节点个数(不统计头节点)

  • 定义一个辅助变量
  • cur = cur.next;//遍历
    public static int getLength(HeroNode head) {
        if (head.next == null) {
            return 0;
        }
        int length = 0;
        //定义一个辅助变量
        HeroNode cur = head.next;
        while (cur != null) {
            length++;
            cur = cur.next;//遍历
        }
        return length;
    }

查找单链表中的倒数第k个结点

  1. 编写一个方法接受head节点,同时接收一个index
  2. index 表示说倒数index个系欸但
  3. 得到链表的总的长度 getLength
  4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
  5. 如果找到了，则返回该节点，否则返回nulll
 /*
   查找单链表中的倒数第k个结点
   思路:
   1.编写一个方法接受head节点,同时接收一个index
   2.index 表示说倒数index个系欸但
   3.得到链表的总的长度 getLength
   4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
   5.如果找到了，则返回该节点，否则返回nulll
    */
    public static HeroNode findLastIndexNode(HeroNode head, int index) {
        //判断是否为空 返回null
        if (head.next == null) {
            return null;
        }
        //遍历得到其长度
        int size = getLength(head);
        if (index <= 0 || index > size) {
            return null;
        }
        //定义辅助遍历 cur, 通过 size-index 确定其位置
        HeroNode cur = head.next;
        for (int i = 0; i < size - index; i++) {
            cur = cur.next;
        }
        return cur;
    }

    /*
    获取到单链表的节点个数(不统计头节点)
     */
    public static int getLength(HeroNode head) {
        if (head.next == null) {
            return 0;
        }
        int length = 0;
        //定义一个辅助变量
        HeroNode cur = head.next;
        while (cur != null) {
            length++;
            cur = cur.next;//遍历
        }
        return length;
    }

}

在这里插入图片描述

反转链表

  1. //设置一个辅助遍历 cur 用来遍历 HeroNode cur = head.next;

  2. //用来存放cur的下一个结点,辅助遍历 HeroNode next = null; 特别注意

  3. 设置一个新链表每取出一个链表的头结点,每次放到新链表reverseHead的头部

  4. 暂时保存cur下一个节点

    //必须保存 保存的是被反转的下一个的节点
/** 这种必然失败
cur.next=reverseHead.next;
reverseHead.next=cur;
cur= cur.next;
*/

  5. 暂时保存cur下一个节点next=cur.next;//

  6. 将cur的下一个节点指向新的链表的最前端cur.next=reverseHead.next;//

  7. 将cur 连接到新的链表上reverseHead.next=cur;//

  8. 将暂时保存cur下一个的节点归还给curcur= next; //

  9. 将head.next 指向 reverseHead.next , 实现单链表的反转 head.next = reverseHead.next;

   //反转链表
    public static void reverList(HeroNode head) {
        //当前链表为空
        if (head.next == null || head.next.next == null) {
            return;
        }
        //设置一个辅助遍历 cur 用来遍历
        HeroNode cur = head.next;
        //用来存放cur的下一个结点,辅助遍历
        HeroNode next = null;
        //设置一个新链表
        HeroNode reverseHead = new HeroNode(0, "");
        //每取出一个链表的头结点,每次放到新链表reverseHead的头部
        while (cur != null){
            //必须保存 保存的是被反转的下一个的节点
            /** 这种必然失败
             cur.next=reverseHead.next;
             reverseHead.next=cur;
             cur= cur.next;
             */
            next=cur.next;//暂时保存cur下一个节点
            cur.next=reverseHead.next;//将cur的下一个节点指向新的链表的最前端
            reverseHead.next=cur;//将cur 连接到新的链表上
            cur= next; //将暂时保存cur下一个的节点归还给cur
        }
        //将head.next 指向 reverseHead.next , 实现单链表的反转
        head.next = reverseHead.next;
    }

在这里插入图片描述

逆序打印

  • 思路一: 将其反转,然后打印,这样会破环链表的本身结构,不利后续的操作
  • 思路二: 利用栈的这个数据结构的特殊性,先进后出,将各个节点的数据压入到栈中,然后将其输出就可以
 public static  void  reversePrint(HeroNode head){
        if (head.next==null){
            return;
        }
        //创建一个栈,将各各节点的数据压入栈中
        Stack<HeroNode> stack = new Stack<>();
        //辅助遍历进行操作
        HeroNode cur =head.next;
        while (cur!=null){
            stack.push(cur);
            cur=cur.next;//cur后移，这样就可以压入下一个节点
        }
        //将栈中的节点进行打印,pop 出栈
        while ((stack.size()>0)){
            System.out.println(stack.pop());//stack的特点是先进后出
        }
    }

在这里插入图片描述

完整代码

package com.nie.linkedlist;

import java.util.Stack;

public class SingleLinkListDemo {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "黎明");
        HeroNode hero2 = new HeroNode(2, "郭富城");
        HeroNode hero3 = new HeroNode(5, "刘德华");
        HeroNode hero4 = new HeroNode(6, "张学友");

        //创建链表
        SingleLinkList singleLinkList = new SingleLinkList();
        //增加结点
        //根据插入的顺序进行插入
        singleLinkList.add(hero1);
        singleLinkList.add(hero2);
        singleLinkList.add(hero3);
        singleLinkList.add(hero4);

        //增加结点
        //根据节点的编号进行插入
//        singleLinkList.addByOrder(hero1);
//        singleLinkList.addByOrder(hero2);
//        singleLinkList.addByOrder(hero4);
//        singleLinkList.addByOrder(hero3);
        singleLinkList.list();
        System.out.println("+++++++++++");
        System.out.println("-------逆序----------");
        System.out.println("逆序打印单链表, 没有改变链表的结构~~");
        reversePrint(singleLinkList.getHead());

        System.out.println("-------反转----------");
        reverList(singleLinkList.getHead());
        singleLinkList.list();
        System.out.println("-------修改-----------");
        HeroNode newHeroNode = new HeroNode(2, "舞王郭富城");
        singleLinkList.update(newHeroNode);
        singleLinkList.list();
        System.out.println("-------删除-----------");
        singleLinkList.del(1);
        singleLinkList.list();

        System.out.println("有效结点的个数" + getLength(singleLinkList.getHead()));
        //测试第倒数几的结点的
        int indexLast = 1;
        HeroNode res = findLastIndexNode(singleLinkList.getHead(), indexLast);
        System.out.println("倒数第" + indexLast + "的结点为" + res);
    }


    //逆序打印
    /*
    思路一: 将其反转,然后打印,这样会破环链表的本身结构,不利后续的操作
    思路二: 利用栈的这个数据结构,将各个节点的数据压入到栈中,然后将其输出就可以
     */
    public static void reversePrint(HeroNode head) {
        if (head.next == null) {
            return;
        }
        //创建一个栈,将各各节点的数据压入栈中
        Stack<HeroNode> stack = new Stack<>();
        //辅助遍历进行操作
        HeroNode cur = head.next;
        while (cur != null) {
            stack.push(cur);
            cur = cur.next;//cur后移，这样就可以压入下一个节点
        }
        //将栈中的节点进行打印,pop 出栈
        while ((stack.size() > 0)) {
            System.out.println(stack.pop());//stack的特点是先进后出
        }
    }

    //反转链表
    public static void reverList(HeroNode head) {
        //当前链表为空
        if (head.next == null || head.next.next == null) {
            return;
        }
        //设置一个辅助遍历 cur 用来遍历
        HeroNode cur = head.next;
        //用来存放cur的下一个结点,辅助遍历
        HeroNode next = null;
        //设置一个新链表
        HeroNode reverseHead = new HeroNode(0, "");
        //每取出一个链表的头结点,每次放到新链表reverseHead的头部
        while (cur != null) {
            //必须保存 保存的是被反转的下一个的节点
            /** 这种必然失败
             cur.next=reverseHead.next;
             reverseHead.next=cur;
             cur= cur.next;
             */
            next = cur.next;//暂时保存cur下一个节点
            cur.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
            reverseHead.next = cur;//将cur 连接到新的链表上
            cur = next; //将暂时保存cur下一个的节点归还给cur
        }
        //将head.next 指向 reverseHead.next , 实现单链表的反转
        head.next = reverseHead.next;
    }


    /*
   查找单链表中的倒数第k个结点
   思路:
   1.编写一个方法接受head节点,同时接收一个index
   2.index 表示说倒数index个系欸但
   3.得到链表的总的长度 getLength
   4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
   5.如果找到了，则返回该节点，否则返回nulll
    */
    public static HeroNode findLastIndexNode(HeroNode head, int index) {
        //判断是否为空 返回null
        if (head.next == null) {
            return null;
        }
        //遍历得到其长度
        int size = getLength(head);
        if (index <= 0 || index > size) {
            return null;
        }
        //定义辅助遍历 cur, 通过 size-index 确定其位置
        HeroNode cur = head.next;
        for (int i = 0; i < size - index; i++) {
            cur = cur.next;
        }
        return cur;
    }

    /*
    获取到单链表的节点个数(不统计头节点)
     */
    public static int getLength(HeroNode head) {
        if (head.next == null) {
            return 0;
        }
        int length = 0;
        //定义一个辅助变量
        HeroNode cur = head.next;
        while (cur != null) {
            length++;
            cur = cur.next;//遍历
        }
        return length;
    }

}


class SingleLinkList {

    //初始化一个头节点
    private HeroNode head = new HeroNode(0, "");


    //返回头节点
    public HeroNode getHead() {
        return head;
    }


    添加节点到单向链表
    /*
    不考虑顺序编号
    1.找的当前链表的最后节点
    2.将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode) {
        //头节点不能动,需要一个辅助遍历temp
        HeroNode temp = head;
        //遍历链表到最后
        while (true) {
            if (temp.next == null) {
                break;
            }
            //如果没有找的,将temp后移
            temp = temp.next;
        }
        //当退出while循环,temp就指向链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }


    /*
  第二种方式在添加英雄时，根据排名将英雄插入到指定位置
(如果有这个排名，则添加失败，并给出提示)
     */
    public void addByOrder(HeroNode heroNode) {
//因为头节点不能动，因此我们仍然通过一个辅助指针(变量)
        //因为单链表,我们找的temp是位于添加位置的前一个节点,否则插入失败
        HeroNode temp = head;
        boolean flag = false; // flag标志添加的编号是否存在，默认为false
        while (true) {
            //说明已经在链表最后了
            if (temp.next == null) {
                break;
            }
            位置找到，就在temp的后面插入
            if (temp.next.no > heroNode.no) {
                break;
                //说明希望添加的heroNode的编号已然存在
            } else if (temp.next.no == heroNode.no) {
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }
        if (false) {
            System.out.println(heroNode.no + "该编号存在");
        } else {
            //插入到链表中, temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点
    public void update(HeroNode heroNode) {
        if (head.next == null) {
            System.out.println("此节点为空");
            return;
        }
        //找到要修改的节点,根据no修改
        //定义一个辅助变量
        HeroNode temp = head;
        boolean flag = false;//表示是否找到该节点
        while (true) {
            if (temp == null) {
                break;//遍历完毕
            }
            if (temp.no == heroNode.no) {
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag判断是否是要修改的节点
        if (flag) {
            temp.name = heroNode.name;
        } else {
            System.out.println("没有找到要修改的编号" + heroNode.no);
        }
    }

    //修改节点
    /*
    思路
    1.head不能动,需要一个辅助变量temp 辅助节点找到要删除的节点
    1.我们在比较的时候只需要找到temp.next.no 和要需要的no作比较
     */
    public void del(int no) {
        //找到要修改的节点,根据no修改
        //定义一个辅助变量
        HeroNode temp = head;
        boolean flag = false;// 标志是否找到待删除节点的
        while (true) {
            if (temp.next == null) { //已经到链表的最后
                break;//遍历完毕
            }
            if (temp.next.no == no) {
                //找到的待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.println("要删除的节点不在" + no);
        }
    }

    //显示链表
    public void list() {
        if (head.next == null) {
            System.out.println("为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while (true) {
            if (temp == null) {
                break;
            }
            //输出结点
            System.out.println(temp);
            temp = temp.next;
        }
    }
}


class HeroNode {
    public int no;
    public String name;
    public HeroNode next;//指向下一个结点

    //构造器
    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}
靠谱的大钊
关注
专栏目录
数据结构与算法---链表
渔潭的博客
02-27 270
数据结构与算法—链表 1. 概念 在讨论链表(linked-list)之前，需要明确几个概念：线性表（顺序表, list, linear list）, 数组(array)，链表(linked-list)。 线性表：在中文里，线性表也叫作顺序表。在英文中，它称为list, linear list等。它是最基础、最简单、最常用的一种基本数据结构，线性表总存储的每个数据称为一个元素，各个元素及其索...
链表-单链表
weixin_34290352的博客
06-04 222
链表(Linked List)介绍 链表是有序的列表，但是它在内存中是存储如下 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表介绍 单链表(带头结点) 逻辑结构示意图如下 单链表的应用实例 使用带head头的单向链表实现 –水浒英雄...
【数据结构与算法】链表
Ye_Ming_OUC的博客
05-15 983
目录什么是链表？单链表创建节点开辟一个新节点单链表尾插单链表尾删单链表头插单链表头删单链表查找单链表插入 - 在给定位置的后部插入单链表插入 - 在给定位置前面插入单链表删除 - 删除给定位置的节点单链表删除 - 删除给定位置后面的节点打印单链表单链表销毁小结带头双向循环链表声明定义节点结构开辟一个新节点创建哨兵位的头节点尾插尾删头插头删查找在给定位置前面进行插入删除给定位置的节点打印销毁链表小结总结 什么是链表？ 我们知道顺序表是以数组的形式存放数据，由于数组是连续存储的，所以顺序表是连续存放数据的，这个
数据结构与算法——链表
SemiraChen的博客
01-29 183
链表 单链表 Message，MessageQueue 单循环链表 双链表 双向循环链表 LinkedList 优点：插入删除快 缺点：不支持随机访问 ##MessageQueue 插入：enqueueMessage()，按照时间顺序插入 删除：next() 整理麻将牌 Mahjong.Class /** * @author CSY * Created by CSY on 2019/1/28...
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
数据结构与算法-学习笔记 Java 版.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
hello-algo-数据结构与算法-zh-csharp.pdf
最新发布
01-24
本书的内容涵盖了数据结构与算法的基础知识，包括数组、链表、栈、队列、树、图等数据结构，以及排序、查找、图形遍历等算法。书中还提供了大量的编程实践和习题，帮助读者更好地掌握数据结构与算法的知识。 本书的...
数据结构和算法-Java版.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
数据结构与算法-链表
weixin_47880716的博客
11-01 368
目录链表链表的设计接口设计清空元素添加元素node方法用于获取index位置的节点删除元素 - remove(int index)SingleLinkedList代码推荐一个神奇的网站双向链表双向链表 VS 动态数组单向循环链表双向循环链表 链表 动态数组有个明显的缺点：可能会造成内存空间的大量浪费。 能否用多少就申请多少内存，链表就可以办到这一点 链表是一种链式存储的线性表，所有元素的内存地址不一定是连续的 链表的设计 接口设计 链表的大部分接口和动态数组是一致的。 把不需要修改的方法写一个父类用来
JavaScript实现单向链表
雨的印记的博客
03-01 382
JavaScript实现单向链表 javascript 数据结构与算法源码 目录JavaScript实现单向链表一、单向链表简介二、封装单向链表类2.0.创建单向链表类2.1.append(element)2.2.toString()2.3.insert(position,element)2.4.get(position)2.5.indexOf(element)2.6.update(position,element)2.7.removeAt(position)2.8.其他方法2.9.完整实现 一、单向链表简
数据结构与算法—链表
weixin_49757069的博客
05-22 351
链表 链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。 链表与数组的对比： 相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。在数组中，我们可以直接访问任何元位置的任何元素，而要想访问链表中间的一个元素，则需要从起点（表头）开始迭代链表直到找到所需的元素。 class Node { constructor(element) { this.el
《数据结构与算法》之链表
菜鸟的向往
05-14 319
最近因为在学习《数据机构与算法》，所以有一段时间没有更新博客了。现在通个写一篇关于链表的博客和一个demo来巩固一下最近的学习，把理论转换为“实战”。 链表结构五花八门，其中最常见的链表结构有单链表、双向链表和循环链表。顺便一提，如果在面试中涉及到到链表，面试官老喜欢问你一句：数组和链表的区别。只要我们理解掌握了什么是链表才能从结构、存储数据、插入、删除上的差异来回答。 在这篇文章先说一下单链表。 首先手写一个单链表 要写一个单链表就必须弄清楚它的数据结构，来一张图看下它长什么样子 清楚了它的数据结构
数据结构与算法 - 链表
niuyanbensi的博客
11-08 250
文章目录前言一、常用链表1.单链表2.双向链表3.循环链表二、链表VS数组三、如何基于链表实现LRU缓存淘汰算法1.常见的三种缓存淘汰策略2.用链表实现LRU缓存淘汰法3.用数组实现LRU缓存淘汰策略四、判断一个字符串是否是回文字符串总结 前言 数组需要一块连续的内存空间来存储，对内存的要求很高，而链表通过指针将一组零散的内存块串联起来使用。链表结构五花八门，三种最常见的链表：单链表、双向链表以及循环链表。 一、常用链表 1.单链表 2.双向链表 3.循环链表 二、链表VS数组 代码如下（示例）： im
Java版数据结构与算法详解：从基础到高级实现
《数据结构与算法（JAVA语言版）-中文》是一本专为Java开发者编写的教材，旨在深入浅出地介绍数据结构与算法的基础理论，并结合Java语言进行实践讲解。该书共分为五章，内容涵盖了Java语言的基本知识、面向对象编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值