LinkedList与链表

2023-09-22 14:40:13

目录

一、Arraylist的缺陷

二、链表

        2.1 链表的概念和结构

        2.2 链表的实现

三、链表面试题

       3.1 删除链表中所有值为val的节点

       3.2 反转一个单链表 

       3.3 链表的中间节点

       3.4 将有序链表合并

       3.5 输出倒数第k个节点

       3.6 链表分割

       3.7 链表的回文结构   

       3.8 找两个链表的公共节点

       3.9 判断链表是否有环

       3.10 找链表入环的第一个节点

四、LinkedList的模拟实现

五、LinkedList的使用

        5.1 什么是LinkedList

        5.2 LinkedList的使用

六、ArrayList和LinkedList的区别

一、Arraylist的缺陷

        ArrayList底层使用数组来存储元素

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
        // ...
        // 默认容量是10
        private static final int DEFAULT_CAPACITY = 10;
        //...
        // 数组：用来存储元素
        transient Object[] elementData; 
        // 有效元素个数
        private int size;
        public ArrayList(int initialCapacity) {
                if (initialCapacity > 0) {
                        this.elementData = new Object[initialCapacity];
                } else if (initialCapacity == 0) {
                        this.elementData = EMPTY_ELEMENTDATA;
                } else {
                        throw new IllegalArgumentException("Illegal Capacity: "+
                        initialCapacity);
                }
        }

        //...

}

        ArrayList底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java集合中引入LinkedList，即链表结构。

二、链表

        2.1 链表的概念和结构

        链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。

        链式结构在逻辑上连续，但在物理上不一定连续；节点一般都是从堆上申请出来的；从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续。

        实际中的链表结构非常多，以下请况组合起来就有8种：

        1. 单向或双向

        2. 带头或不带头

        3. 循环或非循环

        链表有很多，重点掌握两种：

        无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多
        

        无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

        2.2 链表的实现

//无头单向非循环链表实现
public class SingleLinkedList {
        //头插法
        public void addFirst(int data){
        }

        //尾插法
        public void addLast(int data){
        }

        //任意位置插入,第一个数据节点为0号下标
        public void addIndex(int index,int data){
        }

        //查找是否包含关键字key是否在单链表当中
        public boolean contains(int key){
                return false;
        }

        //删除第一次出现关键字为key的节点
        public void remove(int key){
        }

        //删除所有值为key的节点
        public void removeAllKey(int key){
        }

        //得到单链表的长度
        public int size(){
                return -1;
        }

        //清空

        public void clear() {
        }

        //打印

        public void display() {

        }
}

三、链表面试题

        3.1 删除链表中所有值为val的节点

        删除链表中等于给定值val的所有节点  链接​​​​​​

public class ListNode {

        int val;

         ListNode next;

        ListNode() {} ; 

        ListNode(int val) {

                this.val = val;

         }

        ListNode(int val, ListNode next) {

                this.val = val;

                this.next = next;

        }

}

        解法1：遍历整个链表，将其中值为val的节点删除（将要删除节点前的节点的next指向要删除节点后的第一个节点）。

public ListNode removeElements(ListNode head, int val) {

        //原链表是空链表

        if(head==null)

            return head;

        ListNode cur=head;

        //从第二个节点判断

        while(cur.next!=null){

            //下一个节点的值

            if(cur.next.val==val){

                cur.next=cur.next.next;

            }

            else{

                cur=cur.next;

            }

        }

        //判断头节点

        if(head.val==val){

            head=head.next;

        }

        return head;

    }

        解法2：遍历整个链表，将所有值不是给定值val的节点放入新链表中，返回新链表。

public ListNode removeElements(ListNode head, int val) {
        //原链表是空链表
        if(head==null)
            return head;
        //新链表的头节点
        ListNode head1=new ListNode();
        //新链表的节点
        ListNode cur1=head1;
        //原来链表的节点
        ListNode cur=head;
        //遍历原来链表
        while(cur!=null){
            //当前节点的值
            if(cur.val==val)
                cur=cur.next;
            else{
                cur1.next=cur;
                cur=cur.next;
                cur1=cur1.next;
            }
        }
    //如果新链表的尾节点不是原来链表的尾节点，将next置空
        if(cur1.next!=null)
            cur1.next=null;
        return head1.next;
    }

         3.2 反转一个单链表 

        链接

public class ListNode {

         int val;

         ListNode next;

         ListNode() {}

         ListNode(int val) {

                this.val = val;

        }

        ListNode(int val, ListNode next) {

                this.val = val;

                this.next = next;

        }

}

public ListNode reverseList(ListNode head) {

        //原链表为空

        if(head==null)

            return null;

        //原链表只有一个节点

        if(head.next==null)

            return head;

        //原链表的第二个节点开始

        ListNode cur=head.next;

        head.next=null;

        //遍历链表

        while(cur!=null){

            //curNext为当前节点的下一个节点

            ListNode curNext=cur.next;

            //头插法插入节点

            cur.next=head;

            head=cur;

            //当前节点指向原链表位置的下一个节点

            cur=curNext;

        }

        return head;

    }

        3.3 链表的中间节点

        给一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点  链接

 public class ListNode {

        int val;

        ListNode next;

        ListNode() {}

        ListNode(int val) {

                 this.val = val;

         }

        ListNode(int val, ListNode next) {

                this.val = val;

                this.next = next;

        }

}

        解法1：先求链表长度，获取长度一半的节点

public ListNode middleNode(ListNode head) {

            ListNode cur=head;

            //链表的长度

            int count=0;

            while(cur!=null){

                cur=cur.next;

                count++;

               

            }

            int BinaCount=count/2;

            ListNode ret=head;

            for(int i=0;i<BinaCount;i++){

                ret=ret.next;

            }

            return ret;

    }

        缺陷：需要两次遍历才能找到中间节点，当节点较多时，时间复杂度较大。

        解法2：在一次遍历中找到中间节点，两个引用fast和slow分别走两步和一步

public ListNode middleNode(ListNode head) {

            ListNode fast=head;

            ListNode slow=head;

            while(fast!=null&&fast.next!=null){

                fast=fast.next.next;

                slow=slow.next;

            }

            return slow;

    }

          3.4 将有序链表合并

        将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的   链接

public class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) {
                this.val = val;
        }
        ListNode(int val, ListNode next) {
                this.val = val;
                this.next = next;
        }
}

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {

            ListNode NewHead=new ListNode();

            //Newcur 新链表的尾节点

            ListNode Newcur=NewHead;

            while(list1!=null&&list2!=null){

                if(list1.val<list2.val){

                    Newcur.next=list1;

                    list1=list1.next;

                }else{

                    Newcur.next=list2;

                    list2=list2.next;

                }

                Newcur=Newcur.next;

            }

            //list1还有数

            if(list1!=null){

                Newcur.next=list1;

            }

            //list2还有数

            if(list2!=null){

                Newcur.next=list2;

            }

            return NewHead.next;

    }

       3.5 输出倒数第k个节点

        输入一个链表，输出该链表中倒数第k个结点  链接

public ListNode FindKthToTail(ListNode head,int k) {

        //链表为空或k太小

        if(k<=0||head==null){

            return null;

        }

        ListNode fast=head;

        //fast指向第k个节点

        while(k>1){

            fast=fast.next;

            //当k太大

            if(fast==null){

                return null;

            }  

            k--;

        }

        ListNode slow=head;

        //fast没有指向最后一个节点

        while(fast.next!=null){

            fast=fast.next;

            slow=slow.next;

        }

        return slow;

    }

        3.6 链表分割

        编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前        链接

public class ListNode {

    int val;

    ListNode next = null;

    ListNode(int val) {

        this.val = val;

    }

}

public ListNode partition(ListNode pHead, int x) {

        //pmin链表存小于x的节点

        ListNode pmin = null;

        //pin为pmin的尾节点

        ListNode pin = null;

        //pmin链表存大于等于x的节点

        ListNode pmax = null;

        //pax为pmax的尾节点

        ListNode pax = null;

        //遍历链表pHead，将小于x和大于等于x的存入pmin和pmax中

        ListNode cur = pHead;

        while (cur != null) {

            if (cur.val < x) {

                if (pmin == null) {

                    //pmin为空

                    pmin = cur;

                    pin = cur;

                } else {

                    //pmin不为空

                    pin.next = cur;

                    pin = pin.next;

                }

            } else {

                if (pmax == null) {

                    //pmax为空

                    pmax = cur;

                    pax = cur;

                } else {

                    //pmax不为空

                    pax.next = cur;

                    pax = pax.next;

                }

            }

            cur = cur.next;

        }

        if(pmin==null){

            //没有小于x的

            return pmax;

        }

        if(pmax==null){
            //没有大于等于x的

            return pmin;

        }

        //将pmin与pmax串联起来（pmin的尾节点指向pmax的头节点）

        pin.next=pmax;

        if(pax.next!=null){

            pax.next=null;

        }

        return pmin;

    }

       3.7 链表的回文结构   

         链接

public class ListNode {

    int val;

    ListNode next = null;

    ListNode(int val) {

        this.val = val;

    }

}

        反转：

public boolean chkPalindrome(ListNode A) {

        ListNode fast = A;

        //1、找中间节点slow

        ListNode slow = A;

        while (fast != null && fast.next != null) {

            fast = fast.next.next;

            slow = slow.next;

        }

        //2、中间节点之后的反转

        //cur是节点后的第一个节点

        ListNode cur = slow.next;

        slow.next=null;

        while (cur!= null) {

            //保存cur后的第一个节点

            ListNode curNext = cur.next;

            cur.next = slow;

            slow = cur;

            cur = curNext;

        }

        //反转结束后，slow指向最后一个节点

        //3、从第一个节点开始判断

        cur = A;

        while (cur != slow && cur.next != slow) {

            if (cur.val != slow.val) {

                return false;

            } else {

                cur = cur.next;

                slow = slow.next;

            }

        }

        return true;

    }

       3.8 找两个链表的公共节点

        输入两个链表，找出它们的第一个公共结点 链接

public class ListNode {

        int val;

        ListNode next;

        ListNode(int x) {

           val = x;

           next = null;

        }

}

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

        //lenA、lenB分别为链表headA和链表headB的长度

        int lenA = 0;

        int lenB = 0;

        ListNode curA = headA;

        ListNode curB = headB;

        while(curA != null){

            lenA++;

            curA = curA.next;

        }

        while( curB != null){

            lenB++;

            curB = curB.next;

        }

        //pl指向最长链表，ps指向最短链表

        ListNode pl = headA;

        ListNode ps = headB;

        //长度差值len

        int len = lenA-lenB;

        if(len<0){

            //修正pl、ps、len

            pl = headB;

            ps = headA;

            len = lenB-lenA;

        }

        //pl走差值步

        while(len>0){

            pl = pl.next;

            len--;

        }

        //同步走

        while(pl != ps){

            pl = pl.next;

            ps = ps.next;

        }

        //pl为空，没有公共节点

        if(pl == null){

            return null;

        }

        return pl;

    }

       3.9 判断链表是否有环

        给定一个链表，判断链表中是否有环 链接

class ListNode {

        int val;

        ListNode next;

        ListNode(int x) {

            val = x;

            next = null;

        }

}

public boolean hasCycle(ListNode head) {

        //快慢指针

        ListNode fast = head;

        ListNode slow = head;

        while(fast!=null&&fast.next!=null){

            fast=fast.next.next;

            slow=slow.next;

            //相遇->有环

            if(fast==slow){

                return true;

            }

        }

        //循环结束->无环

        return false;

    }

        3.10 找链表入环的第一个节点

        给定一个链表，返回链表开始入环的第一个节点， 如果链表无环，则返回 NULL    链接

class ListNode {

        int val;

        ListNode next;

        ListNode(int x) {

            val = x;

            next = null;

        }

}

public ListNode detectCycle(ListNode head) {

        //快慢指针

        ListNode fast=head;

        ListNode slow=head;

        //找相遇节点

        while(fast!=null&&fast.next!=null){

            fast=fast.next.next;

            slow=slow.next;

            //相遇

            if(fast==slow){

                break;

            }

        }

        //fast=null或fast.next=bull->链表不为环，也就没有入环的第一个节点

        if(fast==null||fast.next==null){

            return null;

        }

        //慢指针从头开始

        slow=head;

        while(slow!=fast){

            slow=slow.next;

            fast=fast.next;

        }

        //循环结束，slow和fast都指向入环的第一个节点

        return slow;

    }

        结论：让一个指针从链表起始位置开始走，同时让一个指针从判环时相遇点的位置开始走，两个指针每次均走一步，最终肯定会在环的入口点的位置相遇。

四、LinkedList的模拟实现

无头双向链表实现
public class MyLinkedList {
        //头插法
        public void addFirst(int data){ }
        //尾插法
        public void addLast(int data){}
        //任意位置插入,第一个数据节点为0号下标
        public void addIndex(int index,int data){}
        //查找是否包含关键字key是否在单链表当中
        public boolean contains(int key){}
        //删除第一次出现关键字为key的节点
        public void remove(int key){}
        //删除所有值为key的节点
        public void removeAllKey(int key){}
        //得到单链表的长度
        public int size(){}
        //打印链表
        public void display (){}
        //清空链表
        public void clear (){}
} 
//无头双向链表的操作
public interface IOPeration {
    //头插法
    public void addFirst(int data);
    //尾插法
    public void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    public boolean addIndex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key);
    //删除第一次出现关键字为key的节点
    public void remove(int key);
    //删除所有值为key的节点
    public void removeAllKey(int key);
    //得到单链表的长度
    public int size();
    //打印链表
    public void display();
    //清空链表
    public void clear();
}
public class MySidesLinkList implements IOPeration{
    static class ListNode {
        int val;
        ListNode pre;
        ListNode next;
        public ListNode(int data){
            val=data;
        }
    }

    private int usedSize;
    private ListNode head;
    private  ListNode last;

    @Override
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if(head == null){
            head = node;
            last = node;
        }else {
            node.next = head;
            head.pre = node;
            head = node;
        }
        usedSize++;
    }

    @Override
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if(last == null){
            head = node;
            last = node;
        }else {
            last.next = node;
            node.pre = last;
            last = node;
        }
        usedSize++;
    }

    @Override
    public boolean addIndex(int index, int data) {
        if(index<0||index>usedSize){
            throw new IndexEception("下标异常："+index);
        }

        if(index == 0){
            addFirst(data);
            return true;
        }
        if(index == usedSize){
            addLast(data);
            return  true;
        }
        ListNode cur=head;
        while(index>0){
            cur = cur.next;
            index--;
        }
        ListNode node = new ListNode(data);
        cur.pre.next = node;
        node.next=cur;
        node.pre = cur.pre;
        cur.pre = node;
        usedSize++;
        return true;
    }

    @Override
    public boolean contains(int key) {
        ListNode cur = head;
        while(cur != null){
            if(cur.val == key){
                return  true;
            }else {
                cur=cur.next;
            }
        }
        return false;
    }

    @Override
    public void remove(int key) {
        ListNode cur = head;
        while(cur != null){
            if(cur.val == key){
                if(cur == head){
                    head = head.next;
                    head.pre = null;
                    cur.next = null;

                }else if(cur == last){
                    last = last.pre;
                    last.next = null;
                    cur.pre = null;
                }else {
                  cur.pre.next = cur.next;
                  cur.next.pre = cur.pre;
                }
                usedSize--;
                return;
            }else {
                cur = cur.next;
            }
        }
    }

    @Override
    public void removeAllKey(int key) {
        ListNode cur = head;
        while(cur != null){
            if(cur.val == key){
                ListNode curNext=cur.next;
                if(cur == head){
                    head = head.next;
                    head.pre = null;
                    cur.next = null;

                }else if(cur == last){
                    last = last.pre;
                    last.next = null;
                    cur.pre = null;
                }else {
                    cur.pre.next = cur.next;
                    cur.next.pre = cur.pre;
                }
                usedSize--;
                cur=curNext;
            }else {
                cur = cur.next;
            }

        }
    }

    @Override
    public int size() {
        return usedSize;
    }

    @Override
    public void display() {
        ListNode cur = head;
        while (cur != null){
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }

    @Override
    public void clear() {
        ListNode cur = head;
        while (cur != null){
            ListNode curNext = cur.next;
            cur.pre = null;
            cur.next = null;
            cur=curNext;
        }
        head = null;
        last = null;
    }
}

//下标异常类
public class IndexEception extends RuntimeException{
    public IndexEception (String massage){
        super(massage);
    }
}

五、LinkedList的使用

        5.1 什么是LinkedList

        LinkedList的底层是双向链表结构，链表没有将元素存储在连续空间中，而是存储在单独的节 点中，通过引用将节点连接起来了，因此在任意位置插入或者删除元素时，不需要搬移元素，效率较高。

在集合框架中，LinkedList也实现了List接口：

        LinkedList实现了List接口，底层使用双向链表；没有实现RandomAccess接口，不支持随机访问；LinkedList在任意位置插入和删除效率较高，时间复杂度为O(1);适合任意位置插入的场景。

        5.2 LinkedList的使用

        1. LinkedList的构造

方法解释

public  LinkedList();

无参构造
public LinkedList(Collection<? extends E> c)使用其他集合容器中元素构造List 
public static void main(String[] args) {
    LinkedList<Integer> list1 = new LinkedList<>();
    list1.addLast(1);
    list1.addLast(2);
    list1.addLast(3);
    //打印链表
    for (Integer x:list1) {
        System.out.print(x+" ");
    }
    System.out.println();
    /*使用list1中的元素构造list2
    * 其中list1的类型是与list2是同类型或是list2的子类类型
    * 存储元素的类型保持一致*/
    LinkedList<Integer> list2 = new LinkedList<>(list1);
    //打印链表
    for (Integer x:list2) {
        System.out.print(x+" ");
    }
    System.out.println();
}

        

        2. LinkedList其他常用方法

方法解释
boolean  add(E e)尾插 e
void add(int index, E element) 将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c) 尾插 c 中的元素
E remove(int index)删除 index 位置元素
boolean remove(Object o) 删除第一个 o
E get(int index) 获取下标 index 位置元素
E set(int index, E element)将下标 index 位置 元素设置为 element
void clear()清空
boolean contains(Object o) 判断 o 是否在链表中
int indexOf(Object o)
返回第一个 o 所在下标
int lastIndexOf (Object o)
返回最后一个 o 的下标
List<E> subList(int fromIndex, int toIndex)
截取部分 list 
public static void main(String[] args) {
    LinkedList<Integer> list = new LinkedList<>();
    list.add(1);//尾插
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    System.out.println(list.size());    //5
    System.out.println(list);   //[1, 2, 3, 4, 5]

    System.out.println("====");
    list.add(2,10);//在 index 位置插入元素
    list.addFirst(10);//头插
    list.addLast(10);//尾插
    System.out.println(list);   //[10, 1, 2, 10, 3, 4, 5, 10]
    System.out.println("====");

    list.remove();//默认删除第一个元素
    System.out.println(list);       //[1, 2, 10, 3, 4, 5, 10]
    list.removeFirst();//删除第一个元素
    System.out.println(list);       //[2, 10, 3, 4, 5, 10]
    list.removeLast();//删除最后一个元素
    System.out.println(list);       //[2, 10, 3, 4, 5]
    list.remove(1);//删除index位置的元素
    System.out.println(list);    //[2, 3, 4, 5]

    System.out.println("====");
    //contains（elem）判断elem元素是否存在
    System.out.println(list.contains(5));//true
    //从前向后找第一个elem出现的位置
    System.out.println(list.indexOf(3));
    //从后向前找第一个elem出现的位置
    System.out.println(list.lastIndexOf(4));
    System.out.println("====");
    //获取index位置的元素
    int elem = list.get(0);
    //set设置index位置的值为elem
    list.set(0,100);
    System.out.println(list);      //[100, 3, 4, 5]

    System.out.println("====");
    //subList截取部分(左闭右开)并返回，返回值类型为List<E>
    List<Integer> list2 = list.subList(0,2);
    System.out.println(list2);  //[100, 3]
}

        3. LinkedList的遍历

public static void main(String[] args) {
    LinkedList<Integer> list = new LinkedList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    //遍历链表
    //foreach遍历
    for (int x:list) {
        System.out.print(x+" ");//1 2 3 4 5
    }
    System.out.println();
    //迭代器遍历
    ListIterator<Integer> it = list.listIterator();
    while (it.hasNext()){
        System.out.print(it.next()+" ");//1 2 3 4 5
    }
    System.out.println();
    //反向迭代器遍历
    ListIterator<Integer> reverseIt = list.listIterator(list.size());
    while (reverseIt.hasPrevious()){
        System.out.print(reverseIt.previous()+" ");//5 4 3 2 1 
    }
}

六、ArrayList和LinkedList的区别

不同点ArrayListLinkedList
存储空间上物理上一定连续逻辑上连续，但物理上不一定连续
随机访问支持O(1)不支持O(N)
头插需要移动元素，效率低O(N)只需修改引用的指向，O(1)
插入空间不够需要扩容没有容量的概念
应用场景元素高效存储、频繁访问任意位置插入和删除频繁

更多推荐

CFCA证书 申请 流程（一）

CFCA证书CFCA证书是指由中国金融认证中心颁发的证书，包括普通数字证书、服务器数字证书和预植证书等，目前，各大银行和金融机构都会使用CFCA颁发的证书作为官网的HTTPS证书、手机银行等APP使用的证书以及USB-KEY（U盾）内置的证书。在案例中包括中国工商银行、中国民生银行、中国光大银行、中信银行、兴业银行、中

NSS [西湖论剑 2022]real_ez_node

NSS[西湖论剑2022]real_ez_node考点：ejs原型链污染、NodeJS中Unicode字符损坏导致的HTTP拆分攻击。开题。附件start.sh。flag位置在根目录下/flag.txtapp.js(这个没多大用)varcreateError=require('http-errors');varexpr

企业微信-通用开发参数回调设置

公司业务需要开发企业微信，注册三方服务商审核通过后，开始配置开发信息。本篇中记录在调试url验证中遇到错误及解决方式。目录准备工作下载php加解密库下载文件说明设置白名单设置路径参数说明设置ip回调处理回调类型：1、Get类型2、Post类型Get回调实现设置路由控制器业务层处理配置开发信息遇到问题发现问题解决方案准备

学习路之工具--SecureCRT的下载、安装

百度盘：链接:https://pan.baidu.com/s/1r3HjEj053cKys54DTqLM4A?pwd=gcac提取码:gcac复制这段内容后打开百度网盘手机App，操作更方便哦感谢大佬简单介绍下SecureCRTSecureCRT是一款支持SSH（SSH1和SSH2）的终端仿真程序，简单地说是Windo

小米云原生文件存储平台化实践：支撑 AI 训练、大模型、容器平台多项业务

小米作为全球知名的科技巨头公司，已经在数百款产品中广泛应用了AI技术，这些产品包括手机、电视、智能音箱、儿童手表和翻译机等。这些AI应用主要都是通过小米的深度学习训练平台完成的。在训练平台的存储方案中，小米曾尝试了多种不同的存储方式，包括Ceph+NFS、HDFS和对象存储挂载等。然而，这些不同的存储方式导致了数据冗余

SpringCloud Gateway搭建Gateway 微服务应用实例

😀前言本篇博文是关于SpringCloudGateway搭建Gateway微服务应用实例，希望你能够喜欢🏠个人主页：晨犀主页🧑个人简介：大家好，我是晨犀，希望我的文章可以帮助到大家，您的满意是我的动力😉😉💕欢迎大家：这里是CSDN，我总结知识的地方，欢迎来到我的博客，感谢大家的观看🥰如果文章有什么需要改进

Linux系统命令——通过端口确认进程及路径方法

一、端口概念在网络技术中，端口（port）大致有两种意思：一是物理意义上的端口比如，ADSLModem、集线器、交换机、路由器用于连接其他网络设备的接口，如RJ-45端口、SC端口等等。二是逻辑意义上的端口，一般是指TCP/IP协议中的端口，端口号的范围从0到65535，比如用于浏览网页服务的80端口，用于FTP服务的

软件测试缺陷报告详解

【软件测试行业现状】2023年了你还敢学软件测试？未来已寄..测试人该何去何从？【自动化测试、测试开发、性能测试】缺陷报告是描述软件缺陷现象和重现步骤地集合。软件缺陷报告SoftwareBugReport（SBR）或软件问题报告SoftwareProblemReport（SPR）作用：缺陷报告是软件测试人员的工作成果之

若依使用及源码解析（前后端分离版）

部署环境JDK>=1.8MYSQL>=5.7Maven>=3.0Node>=12Redis>=3运行若依项目下载若依源码若依官网若依项目源码(前后端分离)运行后端项目ruoyi-ui就是vue项目（这里使用vscode打开）整体用idea打开1.配置数据库(sql提供sql文件中的sql脚本配置)创建数据库ruoyi_

Web安全与攻防

Web安全概述在Internet大众化及Web技术飞速演变的今天，在线安全所面临的挑战日益严峻。伴随着在线信息和服务的可用性的提升，以及基于Web的攻击和破坏的增长，安全风险达到了前所未有的高度。Web安全可以从以下三个方面进行考虑：Web服务器的安全、Web客户端的安全、Web通信信道的安全。针对Web服务器的攻击可

从HTTP到HTTPS:网站安全通信的演进之路

HTTP协议与TCP/IP协议族内的其他协议相同部分，用于客户端和服务器端的通信。下面来看一下HTTP具体是怎么工作的。1、HTTP前生今世在HHTP/0.9版本，主要是通过确立了客户端请求、服务器端响应的通信流程来解决HTML文件传输，只能获取文本资源。HTTP/1.0是一个简单的文本协议，通过设立头部字段来解决不同

热文推荐
  1. Axure设计之数据图表折线图（中继器）

    折线图是一种用于显示数据随时间变化或有序类别关系变化的图形。在折线图中，数据点用线段连接，并按照时间顺序或类别顺序排列。通过观察折线图的走势和变化，可以获得数据变化的趋势和规律。在系统统计分析中折线图经常被使用的数据图表。一、效果展示1、该示例为折线图，分别对客流量和购买量以月份为单位进行统计；2、横轴为统计月份，纵轴

  2. Python经典练习题（一）

    文章目录🍀第一题🍀第二题🍀第三题🍀第四题🍀第五题🍀第一题有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？这里我们使用两种方法进行求解解法一：循环套循环count=0foriinrange(1,5):forjinrange(1,5):forkinrange(1,5):if(i!

  3. 如何辨认是否是高防服务器？

    因为现在高防服务器比较出名，很多IDC服务器商都标榜自己的服务器是高防服务器，那我们怎么辨别服务器商说的高防服务器是否是真正的高防服务器呢？今天小编就告诉大家几点辨认是否是高防服务器的小要点。向选择好的服务器商要一下高防服务器的IP，然后通过简单的测试来看一看，也就是ping指令（用来测试网络连接是否正常）来检查，一般

  4. 如何使用插件扩展Vue的功能

    Vue是一款流行的前端JavaScript框架，它的核心库提供了许多强大的功能，但有时我们需要额外的功能来满足特定需求。这时，使用插件来扩展Vue的功能是一个很好的选择。本文将详细介绍如何使用插件来扩展Vue的功能，包括创建、注册和使用插件。Vue提供了强大的插件系统，供大家来扩展项目功能。开发者可以自由的使用公开的第

  5. Python+pytest接口自动化之参数关联

    一、什么是参数关联？参数关联，也叫接口关联，即接口之间存在参数的联系或依赖。在完成某一功能业务时，有时需要按顺序请求多个接口，此时在某些接口之间可能会存在关联关系。比如：B接口的某个或某些请求参数是通过调用A接口获取的，即需要先请求A接口，从A接口的返回数据中拿到需要的字段值，在请求B接口时作为请求参数传入。二、有哪些

  6. Hoeffing不等式

    在李航老师的统计学习方法（第一版中）Hoeffing不等式Hoeffing不等式Hoeffing不等式是这样子给出的设X1,X2,...,XNX_1,X_2,...,X_NX1​,X2​,...,XN​是独立随机变量，且Xi∈[ai,bi],i=1,2,...,N;SN=∑i=1NXiX_i\in[a_i,b_i],i

  7. VMware Fusion 13在M2芯片的Mac上安装 Windows 11

    首先需要下载Windows11镜像以下给出一种官方方法，当然也可以自己去网上搜索，有很多资源注册微软账号使用注册的账号登录访问：https://www.microsoft.com/en-us/windowsinsider/register使用登录的账号注册Windows11InsiderProgram看到以下页面，就是

  8. 【2023华为杯A题】WLAN网络信道接入机制建模（代码、思路.....)

    💥💥💞💞欢迎来到本博客❤️❤️💥💥🏆博主优势：🌞🌞🌞博客内容尽量做到思维缜密，逻辑清晰，为了方便读者。⛳️座右铭：行百里者，半于九十。📋📋📋本文目录如下：🎁🎁🎁目录💥1背景1.1分布式信道接入和二进制指数退避1.2基于Markovchain的DCF机制建模和系统性能分析📚2WLAN组

  9. Apache shenyu，Java 微服务网关的首选

    微服务网关的产生背景当我们系统复杂度越来越高，团队协作效率越来越低时，我们通常会想到通过"拆分"来应对，这是典型的"化繁为简，分而治之"的思想。在落地过程中，我们通常会引入"SOA"或者"微服务"架构手段，如下图所示：技术更新日新月异，站在当下去看，“微服务”、“API网关”、“云原生”、“servicemesh”…这