(三):链表

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

1.链表介绍

链表是有序的列表，但是他在内存中并不一定是连续的。链表是以节点的方式进行存储，是链式存储。每一个节点包括data域和next域，next域指向下一个节点。链表分为带头节点的链表和没有头结点的链表，根据实际的需求来确定。
其中单链表的逻辑示意图如下：
在这里插入图片描述

2.单链表

2.1单链表的应用实例

使用带head头的单项链表排行榜完成对水浒英雄任务的增删改查操作。

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

在这里插入图片描述

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

在这里插入图片描述

2.1.3修改节点的功能

思路一，先找到该节点，然后遍历，然后修改就中了。

2.1.4删除节点

思路分析示意图：
在这里插入图片描述

2.1.5代码

//定义HeroNode,每一个HeroNode，对象就是一个节点
class HeroNode{
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

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

    }
    //为了显示方便
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +

                '}';
    }
}
//定义SingleLinkedList管理我们的英雄
class SingleLinkedList{
    public HeroNode getHead() {
        return head;
    }

    public void setHead(HeroNode head) {
        this.head = head;
    }

    //初始化一个头结点，头结点不要动
    private HeroNode head=new HeroNode(0,"","");
    //添加节点到单向链表
    //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 tempt=head;
        //标识添加的编号是否存在
        boolean flag=false;
        while (true){
            if (tempt.next==null){
                break;
            }
            if (tempt.next.no>heroNode.no){
                //位置找到，就在temp后面插入
                break;

            }else if (tempt.next.no==heroNode.no){
                flag=true;
                break;
            }
            tempt=tempt.next;
        }
        //判断flag的值
        if (flag){//不能添加说明标号存在
            System.out.println("编号已经存在不能加入"+heroNode.no);

        }else {
            //插入到链表中，temp后面
            heroNode.next=tempt.next;
            tempt.next=heroNode;
        }


    }
    //修改节点的信息，根据编号修改，no编号不能改
    public void update(HeroNode newheroNode){
        //判断是否为空
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode temp=head.next;
        boolean flag=false;//表示是否找到该节点
        while (true){
            if (temp==null){
                break;//到了链表的最后
            }
            if (temp.no==newheroNode.no){
                //找到
                flag=true;
                break;
            }
            temp=temp.next;
        }
        //根据flag判断是否找到要修改的节点
        if (flag){
            temp.name=newheroNode.name;
            temp.nickname=newheroNode.nickname;
        }else {
            //没有找到这个节点
            System.out.println("没有找到编号是这个的"+newheroNode.no);

        }

    }

    //删除节点
    //思路
    //1、head不能动，因此我们需要一个temp辅助节点找到待删除的节点的前一个节点
    //2、我们在比较时候，是temp.next.no和需要删除的节点的no比较
    public void del(int no){
        HeroNode temp=head;
        boolean flag=false;//标识是否找到删除节点的前一个节点
        while(true){
            if (temp.next==null){
                //已经到链表的最后
                break;
            }
            if (temp.next.no==no){
                //找到了待删除节点的前一个节点
                flag=true;
                break;

            }
            temp=temp.next;
        }
        //判断flag
        if (flag){//找到
            //可以删除
            temp.next=temp.next.next;

        }else {
            System.out.println("没找到");
        }
    }

    //显示链表，通过遍历
    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;
        }
    }


}

2.2单链表面试题

2.2.1求单链表有效的节点个数

 //方法：获取单链表的节点个数，如果是带头节点的链表，需求不统计头结点
    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;
    }

2.2.2查找单链表中倒数第n个节点

//查找单链表中的倒数第k个节点
    //1、编写一个方法，接收head节点，同时接收一个index
    //2、index表示倒数第index个节点
    //3、先把链表从头到尾遍历一下，得到链表的总的长度
    //4、得到size后，从链表第一个开始遍历，遍历size-index个
    //5、如果找到嘞，就返回该节点，否则返回null
    public static HeroNode findLastIndexNode(HeroNode head,int index){
        //1、如果链表为空，返回null
        if (head.next==null){
            return null;
        }
        //第一次遍历得到链表的长度
        int size=getLength(head);
        //第二次遍历，size-index位置，就是我们倒数第k个节点
        //先做一个index的校验
        if (index<=0 || index >size){
            return null;

        }
        //定义一个辅助变量
        HeroNode cur=head.next;
        //
        for (int i=0;i<size-index;i++){
            cur=cur.next;
        }
        return cur;
    }

2.2.3单链表的反转

思路分析如下：
在这里插入图片描述
在这里插入图片描述

代码如下：

 //将单链表反转
    public static void reversetList(HeroNode head){
        //如果当前链表为空，或者只有一个节点，无需翻转直接返回
        if (head.next==null||head.next.next==null){
            return;
        }
        //定义一个辅助的指针，帮助我们遍历原来的链表
        HeroNode cur=head.next;
        HeroNode next=null;//定义指向当前节点的下一个节点
        HeroNode reverseHead=new HeroNode(0,"","");
        //遍历原来的链表
        // 并从头遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
        while (cur!=null){
            next=cur.next;//先暂时保存当前节点的下一个节点，因为后面需要使用
            cur.next=reverseHead.next;//将cur下的一个节点指向新的链表
            reverseHead.next=cur;//
            cur=next;//让cur后移

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

2.2.4从尾到头打印链表

思路分析
在这里插入图片描述
代码实现


 //可以使用栈的主句结构，将各个节点压到栈中，然后利用栈的先进后出的特点，实现了逆序打印的效果
    public static void reversePrint(HeroNode head){
        if (head.next==null){
            return;//空链表，无法打印
        }
        //创建一个栈，将各节点压入栈中
        Stack<HeroNode> stack=new Stack<HeroNode>();
        HeroNode cur=head.next;
        //将链表的所有节点压入栈中
        while (cur!=null){
            stack.push(cur);
            cur=cur.next;
        }
        //将栈中的节点进行打印，pop出栈
        while (stack.size()>0){
            System.out.println(stack.pop());
        }
    }

3.双链表

3.1双向链表应用实例

3.1.1双向链表操作分析和实现

使用带head头的双向链表实现-水浒英雄榜
管理单项链表缺点分析：

  • 单向链表，查找的方向只能是一个方向，但是双向链表是可以向前也可以向后查找。
  • 单向链表不能自我删除，需要依赖辅助接点，但是双向链表可以自我删除
  • 双向链表如何完成遍历、添加、修改和删除的思路。
  • 在这里插入图片描述
    1）遍历：和单链表是一样的，只是可以向前查找也可以向后查找。
    2）添加：默认添加到双向链表的最后
  • 先找到双向链表的最后这个节点
  • temp.next=newHeroNode;
  • newHeroNode.pre=temp;
    3)修改 思路和原来的单向链表是一样的
    4)删除
  • 因为是双向链表，因此我们可以实现自我删除某个节点
  • 直接找到这个节点，比如temp
  • temp.pre.next=temp.next
  • temp.next.pre=tem.pre

双向链表的代码实现如下

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        //测试
        System.out.println("双向链表的测试");
        HeroNode2 heroNode1=new HeroNode2(1,"宋江","及时雨");
        HeroNode2 heroNode2=new HeroNode2(2,"卢俊义","玉麒麟");
        HeroNode2 heroNode3=new HeroNode2(3,"吴用","智多星");
        //创建一个双向链表
        DoubleLinkedList doubleLinkedList=new DoubleLinkedList();
        doubleLinkedList.add(heroNode1);
        doubleLinkedList.add(heroNode2);
        doubleLinkedList.add(heroNode3);
        doubleLinkedList.list();
        //修改
        HeroNode2 newHeroNode=new HeroNode2(3,"公孙胜","入云龙");
        doubleLinkedList.update(newHeroNode);
        doubleLinkedList.list();
        //删除
        doubleLinkedList.del(3);
        doubleLinkedList.list();
    }
}
//创建一个双向链表的类
class DoubleLinkedList{
    //先初始化一个头结点，头结点不要动，不存放具体的位置
    private HeroNode2 head=new HeroNode2(0,"","");
    public HeroNode2 gethead(){
        return head;
    }
    //遍历双向链表的方法
    //显示链表
    public void list(){
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        //因为头结点不能动，因此我们需要一个辅助变量完成遍历
        HeroNode2 temp=head.next;
        while (true){
            //判断是否到了最后
            if (temp==null){
                break;
            }
            //输出这个节点的信息
            System.out.println(temp);
            temp=temp.next;
        }
    }
    public void add(HeroNode2 heroNode){
        //因为头结点不能动，所以我们需要一个辅助遍历temp
        HeroNode2 temp=head;
        //遍历链表，找到最后
        while (true){
            //
            if (temp.next==null){
                break;
            }
            //如果没有找到最后，就将temp后移动
            temp=temp.next;
        }
        //当退出while循环时候，temp就指向了链表最后
        //将这个节点的next指向新的节点
        temp.next=heroNode;
        heroNode.pre=temp;

    }
    //修改一个节点的内容
    public void update(HeroNode2 newheroNode){
        //判断是否为空
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode2 temp=head.next;
        boolean flag=false;//表示是否找到该节点
        while (true){
            if (temp==null){
                break;//到了链表的最后
            }
            if (temp.no==newheroNode.no){
                //找到
                flag=true;
                break;
            }
            temp=temp.next;
        }
        //根据flag判断是否找到要修改的节点
        if (flag){
            temp.name=newheroNode.name;
            temp.nickname=newheroNode.nickname;
        }else {
            //没有找到这个节点
            System.out.println("没有找到编号是这个的"+newheroNode.no);

        }

    }
    //从双向链表中删除一个节点
    //说明
    //1 对于双向链表，我们可以直接查找到要删除的这个节点
    //2 找到后，自我删除即可

    public void del(int no){
        //判断当前链表是否为空
        if (head.next==null){
            System.out.println("链表为空，无法删除");
            return;
        }
        HeroNode2 temp=head.next;
        boolean flag=false;//标识是否找到删除节点的前一个节点
        while(true){
            if (temp==null){
                //已经到链表的最后
                break;
            }
            if (temp.no==no){
                //找到了待删除节点的前一个节点
                flag=true;
                break;

            }
            temp=temp.next;//temp后移，遍历
        }
        //判断flag
        if (flag){//找到
            //可以删除
           temp.pre.next=temp.next;
           //如果是最后一个节点 就不需要执行下面那个
            if (temp.next!=null){
                temp.next.pre=temp.pre;

            }


        }else {
            System.out.println("没找到");
        }
    }



}
class HeroNode2{
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next;//指向下一个节点
    public  HeroNode2 pre;//指向前一个节点

    public HeroNode2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;

    }
    //为了显示方便
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +

                '}';
    }
}

4.单项环形链表

Josephu(约瑟夫)问题
设编号为1，2,3，…n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，直到m的那个人出列，他的下一位又从1开始报数，数到m的那个人又出列，以此类推，直到所有人出列为止，由此得出产生一个出队列的编号的序列。
提示：用一个不带头节点的循环链表来处理约瑟夫问题，先构成一个有n个节点的单循环链表，然后从k开始从1开始计数，记到m时，对应节点从链表删除，然后再从被删除节点的下一个节点又从1开始计数，知道最后一个节点从链表中删除，算法结束。

4.1单向环形链表介绍

在这里插入图片描述

4.2约瑟夫问题

在这里插入图片描述

  • 创建链表思路图解

在这里插入图片描述

  • 约瑟夫问题-小孩出圈的思路分析
    在这里插入图片描述

4.3约瑟夫问题代码


public class Josepfu {
    public static void main(String[] args) {
        //测试一把看看构建环形链表。遍历是否ok
        CircleSingleLinkedList circleSingleLinkedList=new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.showBoy();
        //测试一下小孩出圈是否正确
        circleSingleLinkedList.countBoy(1,2,5);


    }
}
//创建一个环形的单项链表
class CircleSingleLinkedList{
    //创建一个first节点
    private Boy first;
    //添加节点,构建环形链表
    public void addBoy(int nums){
        //nums做一个数据校验
        if (nums<1){
            System.out.println("数值不正确");
            return;
        }
        Boy curBoy=null;//辅助指针，构建环形链表
        //使用循环创建我们的环形链表
        for (int i=1;i<=nums;i++){
            //根据编号创建小孩节点
            Boy boy=new Boy(i);
            //如果是第一个小孩
            if (i==1){
                first=boy;
                first.setNext(first);//构成环
                curBoy=first;//让curBoy指向第一个小孩
            }else {
                curBoy.setNext(boy);
                boy.setNext(first);
                curBoy=boy;
            }


        }

    }
    //遍历所有的环形链表
    public void showBoy(){
        //判断链表是否为空
        if (first==null){
            System.out.println("没有任何小孩");
            return;
        }
        //因为first不能动，因此我们依然使用一个辅助指针完成
        Boy curBoy=first;
        while (true){
            System.out.printf("小孩的编号%d \n",curBoy.getNo());
            if (curBoy.getNext()==first){//说明遍历完毕
                break;

            }
            curBoy=curBoy.getNext();
        }
    }
    //根据用户输入，计算出圈的顺序

    /**
     *
     * @param startNo:表示从第几个小孩开始数
     * @param count：表示数几下
     * @param nums：表示最初有多少小孩在圈中
     */
    public void countBoy(int startNo,int count,int nums){
        //先对数据进行校验
        if (first==null||startNo<1||startNo >nums){
            System.out.println("参数输入有误，请从新输入");
            return;
        }
        //创建一个辅助指针，帮助完成小孩出圈
        Boy helper=first;
        //需求创建一个辅助指针变量helper，实现应该形成环形链表的最后这个节点
        while (true){
            if (helper.getNext()==first){//说明helper指向最后的小孩节点
                break;
            }
            helper=helper.getNext();
        }
        //小孩宝数千，先让first和helper移动k-1次
        for (int j=0;j<startNo-1;j++){
            first=first.getNext();
            helper=helper.getNext();
        }
        //当小孩报数时，让first和helper指针同时移动m-1次
        //这是一个循环的操作，直到圈中只有一个节点
        while (true){
            if (helper==first){//说明圈中只有一个节点
                break;
            }
            //让first和helper同时移动countNum-1
            for (int j=0;j<count-1;j++){
                first=first.getNext();
                helper=helper.getNext();

            }
            //这时，first指向的节点，就是要出圈的节点
            System.out.printf("小孩%d出圈 \n",first.getNo());
            //这时将first指向的小孩出圈
            first=first.getNext();
            helper.setNext(first);

        }
        System.out.printf("最后留在圈中的小孩编号：%d \n",first.getNo());




    }



}
//创建一个boy类，表示一个节点
class Boy{
    private int no;//编号
    private Boy next;//指向下一个节点，默认是null
    public Boy(int no){
        this.no=no;
    }

    public int getNo() {
        return no;
    }

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

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }
}
bupt_01
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript中数据结构与算法(三)：链表
10-24
主要介绍了JavaScript中数据结构与算法(三)：链表,本文分别讲解了单链表与双链表以及增加节和删除节的代码实例,需要的朋友可以参考下
数据结构实验之链表三：链表的逆置
qq_52358084的博客
03-12 1410
数据结构实验之链表三：链表的逆置 (20 分) 输入多个整数，以-1作为结束标志，顺序建立一个带头结点的单链表，之后对该单链表的数据进行逆置，并输出逆置后的单链表数据。 输入格式: 输入多个整数，以-1作为结束标志。（整数个数不超过100000，不低于1） 输出格式: 输出逆置后的单链表数据。 输入样例: 12 56 4 6 55 15 33 62 -1 输出样例: 62 33 15 55 6 4 56 12 #include<stdio.h> #include<stdlib.h>
入坑三：链表中对cur=cur.next理解的误区
weixin_42258216的博客
11-19 4708
情况说明：在CSDN中看到了对程序算法网站“力扣”的推荐，附网站地址：https://leetcode-cn.com/ 在里面看到关于链表的算法题，但是在使用链表时存在这样的疑问，如图： 调试中的数据变化： 这里我对cur = cur.next产生了误解，将其看作类似引用类型的值传递问题，最后我在另一篇博文中找到了正确解释（图片引用地址：https://blog.csdn.net/qq_426...
线性结构：链表
轻松的小希
03-05 3427
目录第一章 单向链表介绍第二章 单向链表实现2.01、初始化链表的结构2.02、判断链表是否为空2.03、获取当前链表长度2.04、连接链表两个结点2.05、释放链表结点指向2.06、返回链表最后结点2.07、返回链表首个结点2.08、返回指定位置结点2.09、链表尾后添加数据2.10、链表头后添加数据2.11、指定位置添加数据2.12、删除指定位置结点2.13、删除链表首个结点2.14、删除链表最后结点2.15、顺序输出链表内容2.16、逆序输出链表内容2.17、首尾反转当前链表2.18、清空链表所有结点
数据结构：链表及其C++实现
热门推荐
forGemini的博客
05-26 1万+
前言 链表是一种非常非常基础的数据结构，本文首先讲解链表的基础知识，然后使用C++的模板实现了一个链表类，并简单实现了常见的插入、删除、查找等算法。 阅读本文需要对C/C++的指针具有一定的了解。 基础知识 链表是一种逻辑上连续，内存上分散的线性表数据结构，其基本单位为结点，每个结点分数据区和指针区，数据区用于存放数据，指针区则用于指向其他结点，通过指针每个结点就被串接成了一条“链子”。
数据结构三：链表(LinkList)的原理及基本操作
a18209153799的博客
01-22 1872
什么是链表？         链表是一种数据结构，其特点是每一个结构都带有指向下一个节点的指针和一个data，相较于顺序表来说，链表在内存中的储存不需要连续，靠着指针寻找下一个节点，不支持随机访问，但是插入/删除的效率高（时间复杂度是 O(1)）。   链表的分类         链表可以分为带头节点的单链表，不带头节点的单链表，双链表，双向循环链表等等。今天主要讲不带头节点的单链表。  链表...
C例子：链表
06-13
该程序是我写的博客“一起talk C栗子吧（第十三回：C语言实例--单链表二）”的配套程序，共享给大家使用
前端学数据结构与算法（三）：链表为什么能和数组相提并论？实现数组bettle下 数组和链表.pdf
04-18
前端学数据结构与算法（三）：链表为什么能和数组相提并论？实现数组bettle下 数组和链表.pdf
23：链表中的环的入口结点（剑指offer第2版Python）
01-21
寻找链表中环的入口结点主要分成三个步骤： 首先是设置两个快慢指针，如果快慢指针相遇，则快慢指针必然都在环中； 然后从相遇的地方设置一个指针向后遍历并记录走的步数，当这个指针重新指到开始的位置的时候，当前...
jdk8新特性----Lambda表达式
w_t_y_y的博客
05-11 442
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
jar包增量更新分析
junlaiyan的专栏
05-16 138
借助jdeps分析出jar包的增量文件
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 521
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 204
java导出excel动态加载多sheet多复杂表头
Android Model引入其他aar包 导致无法打包成aar
最新发布
qq_27400335的博客
05-16 236
Android Model引入其他aar包 导致无法打包成aar
java中实现缓存的几种方式
shenxiaomo1688的博客
05-16 678
Redis 是C语言开发的一个开源高性能键值对的内存数据库，可以用来做数据库、缓存、消息中间件等场景，是一种NoSQL(not-only sql,非关系型数据库)的数据库。下面我们介绍在springboot项目中的使用springboot中有redis的starter我们直接引用即可然后在spring配置文件中加入如下设置，这里用的是properties形式的文件，host是部署redis的服务器ip，port是端口号，password是密码，如果没有设置密码不填即可同样我们编写接口测试。
设计模式-责任链模式
weixin_43880576的博客
05-11 995
责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
brupsuite各版本专业破解安装
weixin_51520483的博客
05-11 199
最新brupsuite专业版安装，全套安装软件+环境，附带安装包教程
Spring Cloud 概述及项目创建
qq_66292058的博客
05-13 721
在介绍什么是微服务之前，我们先来了解一下什么集群和分布式的概念。Spring Cloud是微服务架构的一站式解决方案，它对一系列用来实现微服务或解决微服务带来的问题的组件进行了整合，例如实现负载均衡，服务调用和服务发现，分布式版本配置 ，断路器，分布式消息等功能的组件，并将这些组件按照Spring Cloud的规范进行管理。Spring Cloud并不自己实现这些组件，而是对其进行管理，并提供给用户进行使用。
2024OD机试卷-智能成绩表 (java\python\c++)
WRJ_Jack的博客
05-12 40
小明来到某学校当老师，需要将学生按考试总分或单科分数进行排名，你能帮帮他吗？
7-3 数据结构实验之链表三：链表的逆置
06-28
链表的逆置是指将链表中的元素顺序颠倒过来，即原来的第一个元素变成最后一个，原来的最后一个元素变成第一个，以此类推。这个操作在实际编程中非常常见，可以用来解决很多问题。 实现链表的逆置需要遍历整个链表，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值