LinkedList与链表

目录

一、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;@Overridepublic 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++;}@Overridepublic 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++;}@Overridepublic 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;}@Overridepublic boolean contains(int key) {ListNode cur = head;while(cur != null){if(cur.val == key){return  true;}else {cur=cur.next;}}return false;}@Overridepublic 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;}}}@Overridepublic 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;}}}@Overridepublic int size() {return usedSize;}@Overridepublic void display() {ListNode cur = head;while (cur != null){System.out.print(cur.val+" ");cur = cur.next;}System.out.println();}@Overridepublic 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());    //5System.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位置的值为elemlist.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)
插入空间不够需要扩容没有容量的概念
应用场景元素高效存储、频繁访问任意位置插入和删除频繁

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.xdnf.cn/news/144681.html

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

23.1 Bootstrap 表格

23.1 Bootstrap 表格

1. 表格 1.1 基础表格 Bootstrap5 通过在<table>元素中添加.table类来设置基础表格的样式.<!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-wi…
阅读更多...
零基础教程：Yolov5模型改进-添加13种注意力机制

零基础教程：Yolov5模型改进-添加13种注意力机制

1.准备工作 先给出13种注意力机制的下载地址&#xff1a; https://github.com/z1069614715/objectdetection_script 2.加入注意力机制 1.以添加SimAM注意力机制为例&#xff08;不需要接收通道数的注意力机制&#xff09; 1.在models文件下新建py文件&#xff0c;取名叫Sim…
阅读更多...
路由器配置单区域（多区域）OSPF

路由器配置单区域（多区域）OSPF

目录 实验原理 案例 路由器配置单区域OSPF基本功能 单区域总结 路由器配置多区域OSPF基本功能 多区域特点 实验原理 OSPF&#xff08;Open Shortest Path First&#xff0c;开放最短路径优先&#xff09;是互联网的标准协议&#xff0c;是为克服RIP的缺点而开发的。目前针…
阅读更多...
win10搭建Selenium环境+java+IDEA（2）

win10搭建Selenium环境+java+IDEA（2）

接着上一个搭建环境开始叙述&#xff1a;win10系统x64安装java环境以及搭建自动化测试环境_荟K的博客-CSDN博客 上一步结尾的浏览器驱动&#xff0c;本人后面改到了谷歌浏览器.exe文件夹下&#xff1a; 这里需要注意&#xff0c;这个新路径要加载到系统环境变量中。 上一步下…
阅读更多...
排序学习总结

排序学习总结

取每个对象的内接矩形框&#xff0c;然后再排序&#xff0c;根据排序的结果确定原对象顺序。 inner_rectangle1(RegionAffineTrans1, Row1, Column1, Row2, Column2) gen_rectangle1(Rect,Row1, Column1, Row2, Column2) sort_region(Rect,RectSort,character,true, row)count…
阅读更多...
小波变换学习笔记【1】

小波变换学习笔记【1】

【声明】本博客为学习B站视频小波分解与重构所做笔记&#xff0c;供自己和大家查阅学习&#xff0c;想查看 up 原视频请移步 B 站&#xff0c;侵删。 1.1 小波变换的由来 傅里叶变换基本思想&#xff1a;将信号分解成一系列不同频率的连续正弦波的叠加。 其缺点是&#xff0c;…
阅读更多...
进入IT行业：选择前端开发还是后端开发？

进入IT行业：选择前端开发还是后端开发？

一、前言 开发做前端好还是后端好&#xff1f;这是一个常见的问题&#xff0c;特别是对于初学者来说。在编程世界中&#xff0c;前端开发和后端开发分别代表着用户界面和数据逻辑&#xff0c;就像城市的两个不同街区一样。但是&#xff0c;究竟哪个街区更适合我们作为开发者呢…
阅读更多...
Redis过期删除策略和内存淘汰策略的区别

Redis过期删除策略和内存淘汰策略的区别

过期删除策略 有关过期时间的设置和查询 查看某个 key 剩余的存活时间&#xff0c;可以使用 TTL 命令&#xff08;单位是秒&#xff09;。 取消 key 的过期时间&#xff0c;则可以使用 PERSIST 命令。 # 取消 key1 的过期时间 > persist key1 (integer) 1# 使用完 persist…
阅读更多...
分类预测 | MATLAB实现WOA-FS-SVM鲸鱼算法同步优化特征选择结合支持向量机分类预测

分类预测 | MATLAB实现WOA-FS-SVM鲸鱼算法同步优化特征选择结合支持向量机分类预测

分类预测 | MATLAB实现WOA-FS-SVM鲸鱼算法同步优化特征选择结合支持向量机分类预测 目录 分类预测 | MATLAB实现WOA-FS-SVM鲸鱼算法同步优化特征选择结合支持向量机分类预测效果一览基本介绍程序设计参考资料 效果一览 基本介绍 MATLAB实现WOA-FS-SVM鲸鱼算法同步优化特征选择结…
阅读更多...
Flutter笔记：用于ORM的Floor框架简记

Flutter笔记：用于ORM的Floor框架简记

Flutter笔记 用于ORM的Floor框架简记 本文地址&#xff1a;https://blog.csdn.net/qq_28550263/article/details/133377191 【介绍】&#xff1a;最近想找用于Dart和Flutter的ORM框架&#xff0c;偶然间发现了Floor&#xff0c;觉得还不错&#xff0c;做一些记录。 1. Floor 框…
阅读更多...
wsl2 更新报错问题解决记录

wsl2 更新报错问题解决记录

1、问题 win10 中安装的 wsl2&#xff0c;启动 docker desktop 时提示 wsl2 有问题&#xff1a; 于是点击推荐的地址连接到微软&#xff0c;下载 wsl2 的更新文件。之后运行&#xff0c;又报错&#xff1a; 更新被卡住。 2、解决方法 WinR 输入 cmd 打开命令行窗口&#x…
阅读更多...
Spring面试题7：面试官：Spring是如何进行异常处理的呢？

Spring面试题7：面试官：Spring是如何进行异常处理的呢？

该文章专注于面试，面试只要回答关键点即可，不需要对框架有非常深入的回答，如果你想应付面试，是足够了，抓住关键点 面试官：Spring是如何进行异常处理的呢？ Spring通过异常处理机制来处理应用程序中的异常。它提供了多种方式来处理异常，包括以下几种： 声明式事务管理：…
阅读更多...
目标检测如何演变：从区域提议和 Haar 级联到零样本技术

目标检测如何演变：从区域提议和 Haar 级联到零样本技术

目录 一、说明 二、目标检测路线图 2.1 路线图&#xff08;一般&#xff09; 2.2 路线图&#xff08;更传统的方法&#xff09; 2.3 路线图&#xff08;深度学习方法&#xff09; 2.4 对象检测指标的改进 三、传统检测方法 3.1 维奥拉-琼斯探测器 (2001) 3.2 HOG探测器…
阅读更多...
Video Caption / 视频字幕：常用指标（BELU-4，ROUGE-L，METEOR，CIDEr，SPICE）和数据集总结

Video Caption / 视频字幕：常用指标（BELU-4，ROUGE-L，METEOR，CIDEr，SPICE）和数据集总结

本文作为入门Video Caption / 视频字幕 的随笔记录&#xff0c;用于查漏补缺和回顾&#xff0c;难免有疏漏和不足指出&#xff0c;烦请指出&#xff01; 一、指标 Video Caption / 视频字幕常用的标准指标有四种&#xff1a;BLEU-1[1]&#xff0c;BLEU-2[1]&#xff0c;BLEU-3[…
阅读更多...
Oracle 11g RAC部署笔记

Oracle 11g RAC部署笔记

搭了三次才搭好&#xff0c;要记录一下。 1. Oracle 11g RAC部署的相关步骤以及需要的包&#xff0c;可以参考这里。 Oracle 11g RAC部署_12006142的技术博客_51CTO博客Oracle 11g RAC部署&#xff0c;Oracle11gRAC部署操作环境&#xff1a;CentOS7.4Oracle11.2.0.4一、主机网…
阅读更多...
第十四届蓝桥杯大赛软件赛决赛 C/C++ 大学 B 组 试题 C: 班级活动

第十四届蓝桥杯大赛软件赛决赛 C/C++ 大学 B 组 试题 C: 班级活动

[蓝桥杯 2023 国 B] 班级活动 【问题描述】 小明的老师准备组织一次班级活动。班上一共有 n n n 名&#xff08; n n n 为偶数&#xff09;同学&#xff0c;老师想把所有的同学进行分组&#xff0c;每两名同学一组。为了公平&#xff0c;老师给每名同学随机分配了一个 n n …
阅读更多...
（三）Python变量类型和运算符

（三）Python变量类型和运算符

所有的编程语言都支持变量&#xff0c;Python 也不例外。变量是编程的起点&#xff0c;程序需要将数据存储到变量中。 变量在 Python 内部是有类型的&#xff0c;比如 int、float 等&#xff0c;但是我们在编程时无需关注变量类型&#xff0c;所有的变量都无需提前声明&#x…
阅读更多...
腾讯云cvm云硬盘扩容

腾讯云cvm云硬盘扩容

过去一直记得腾讯云的系统盘扩容,关于系统盘的扩容直接点资源调整-云硬盘扩容 系统盘扩容后就可以直接使用的&#xff1f; 但是现在操作了发现vda 200G 但是现在vda1不能自动扩容了&#xff1f; 腾讯云cvm云硬盘扩容 先看一眼官方文档吧&#xff1a;在线扩展系统盘分区及文…
阅读更多...
Unity如何生成随机数（设置种子）

Unity如何生成随机数（设置种子）

文章目录 随机类整数二维向量三维向量种子其他文章 随机类 我们可以使用Random类来生成一些随机数 Random类是用于生成随机数的类之一。它可以用于生成不同类型的随机数&#xff0c;如整数、浮点数和向量。 整数 我们可以使用Random.Range来生成指定范围内的随机整数或浮点数…
阅读更多...
22 mysql range 查询

22 mysql range 查询

前言 这里主要是 探究一下 explain $sql 中各个 type 诸如 const, ref, range, index, all 的查询的影响, 以及一个初步的效率的判断 这里会调试源码来看一下 各个类型的查询 需要 lookUp 的记录 以及 相关的差异 此系列文章建议从 mysql const 查询 开始看 测试表结构…
阅读更多...
最新文章

Copyright @ 2022~2023