认识单链表

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

认识单链表

一、ArrayList的优点及缺陷

优点：
适合给定下标位置进行查找元素。此时可以达到O(1)。
缺陷：

  1. 由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。
  2. ArrayList是按照1.5倍大小来扩容的。假设现在有100个空间，而我们恰恰需要101个空间，这时候默认会扩容为150个空间，造成了空间的严重浪费。

因此：java集合中又引入了LinkedList，即链表结构。

二、链表

2.1 链表的概念及结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
在这里插入图片描述
在这里插入图片描述
注意:

  1. 从上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续
  2. 现实中的结点一般都是从堆上申请出来的
  3. 从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
虽然有这么多的链表的结构，但是我们重点掌握两种:

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

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

2.2 链表的实现

先用一个比较low的办法来实现MySingleList：

public class MySingleList {
    /**
     * 节点内部类
     */
    static class ListNode{
        public int val;
        public ListNode next;

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

    public ListNode head; // 不初始化了，默认就是null

    public void createList(){
        ListNode listNode1 = new ListNode(1);
        ListNode listNode2 = new ListNode(2);
        ListNode listNode3 = new ListNode(3);
        ListNode listNode4 = new ListNode(4);
        ListNode listNode5 = new ListNode(5);
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        listNode4.next = listNode5;

        this.head = listNode1;
    }
}

public class Test {
    public static void main(String[] args) {
        MySingleList mySingleList = new MySingleList();
        mySingleList.createList();
    }
}

一般情况下，链表并不是用以上方式构造，而是通过add方法构造的：

public class Test {
    public static void main(String[] args) {
        MySingleList mySingleList = new MySingleList();
        mySingleList.addFirst(3);
        mySingleList.addFirst(2);
        mySingleList.addLast(4);
        mySingleList.addFirst(1);
        mySingleList.addLast(5);
        mySingleList.display();
    }
}

display方法：
三个细节：
在这里插入图片描述

  1. 拷贝一个head指针来移动；
  2. while判断条件不能为cur -> next != null；
  3. 通过cur = cur.next来使cur走动。

addFirst方法：
比起顺序表的好处是：插入数据的时候不用挪动元素，只需要修改指向即可。
链表的插入和删除不是所有情况下都比顺序表快，比如尾插尾删，顺序表的时间复杂度为O（1），并且如果是单链表，如果要在中间某个节点的前面插入/删除一个节点，则需要遍历。所以时间的快慢要分情况看待。

细节：
在这里插入图片描述
若是一个空链表，也没有任何问题：
在这里插入图片描述
技巧：当你在链表当中插入一个数据的时候，一定要记住先去绑定后面的节点。

addLast方法：
细节：

    public void addLast(int data){
		ListNode node = new ListNode(data);

        ListNode cur = this.head;
        while(cur.next != null){
            cur = cur.next;
        }
        // 到这里cur已经是尾巴节点了
        cur.next = node;
    }

以上代码，若本身就是一个空链表（head = null）呢？？？空指针异常！！！
所以我们需要先去判断是否为空，正确代码：

    public void addLast(int data){
        ListNode node = new ListNode(data);

        ListNode cur = this.head;
        if(cur == null){
            this.head = node;
        }else{
            while(cur.next != null){
                cur = cur.next;
            }
            // 到这里cur已经是尾巴节点了
            cur.next = node;
        }
    }

addIndex方法：

    public void addIndex(int index,int data){}

细节：

  1. 先判断index的合法性：
    index < 0 || index > size()：不合法（抛异常）；
    index == 0：头插；index == size()：尾插。
  2. 头插或者尾插情况完成后一定要return;！！！

在这里插入图片描述
注意：
方法内部需要的接口方法可以用private来封装，不会被类外看到。
（比如此方法里调用的 findIndexSubOne 方法）

remove方法：
细节：
在这里插入图片描述

  1. 对空链表、删除第一个节点情况特殊处理 （记得return！！！）
  2. 先找到 del(key) 的前一个节点
  3. cur.next = cur.next.next;

注意：
下面找key前一个位置的代码有什么问题？

    private ListNode findPrevOfKey(int key){
        ListNode cur = this.head;
        while(cur.next.val != key){
            cur = cur.next;
        }
        return cur;
    }

答：若key不存在，上述代码运行时会发生空指针异常！所以，我们应该再加一层限制：

    private ListNode findPrevOfKey(int key){
        ListNode cur = this.head;
        while(cur.next != null){
            if(cur.next.val == key){
                return cur;
            }
            cur = cur.next;
        }
        // 没找到 return null;
        return null;
    }

removeAllKey方法：
有的同学可能会这样想：我们循环调用刚刚讲解的remove方法不就可以了？那么循环多少次呢？假设有n个节点，我们循环n次的话，整个时间复杂度就达到了O(n2)，并不是一个好方法！！！
首先，我们判断是否为空链表，若是直接return；
其次，我们可以定义前后两个指针：
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
而第一个节点需要单独判断：

  1. 若放在上述代码之后：
    在这里插入图片描述
  2. 若放在上述代码之前：
    需要把 if 改成 while：把第一个位置的key值节点全部删除完。

clear()方法：
当我们让 head = null 时，第二个节点就没有对象引用，被回收，以此类推。

代码实现：

public class MySingleList {
    /**
     * 节点内部类
     */
    static class ListNode{
        public int val;
        public ListNode next;

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

    public ListNode head; // 不初始化了，默认就是null


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

    public int size(){
        int count = 0;
        ListNode cur = this.head;
        while(cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    }

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

    public void addFirst(int data){
        ListNode node = new ListNode(data);
        node.next = head;
        head = node;
    }

    public void addLast(int data){
        ListNode node = new ListNode(data);

        ListNode cur = this.head;
        if(cur == null){
            this.head = node;
        }else{
            while(cur.next != null){
                cur = cur.next;
            }
            // 到这里cur已经是尾巴节点了
            cur.next = node;
        }
    }

    public void addIndex(int index,int data) throws IndexWrongfulException{
    	// 1.判断index合法性
        if(index < 0 || index > this.size()){
            throw new IndexWrongfulException("index位置不合法");
        }
        // 2.特殊位置插入
        if(index == 0){
            this.addFirst(data);
            return;
        }
        if(index == size()){
            this.addLast(data);
            return;
        }
        // 3.中间插
        // new
        ListNode node = new ListNode(data);
        // 先走 index-1 步，找到 cur
        ListNode cur = this.findIndexSubOne(index);
        // 修改指向
        node.next = cur.next;
        cur.next = node;
    }

    private ListNode findIndexSubOne(int index){  // 不用判断index合法性，因为走到这儿index一定合法了
        ListNode cur = this.head;
        while((index-1) != 0){
            cur = cur.next;
            index--;
        }
        return cur;
    }

    public void remove(int key){
        // 空链表：
        if(this.head == null){
            return;
        }
        // 删除第一个节点：
        if(this.head.val == key){
            this.head = this.head.next;
            return;
        }

        ListNode cur = this.findPrevOfKey(key);
        if(cur == null){     // 可能就没有key数据！！！
            System.out.println("没有你要删除的数字！");
            return;
        }
        ListNode del = cur.next;
        cur.next = del.next;
        // 或 cur.next = cur.next.next;
    }

    private ListNode findPrevOfKey(int key){
        ListNode cur = this.head;
        while(cur.next != null){
            if(cur.next.val == key){
                return cur;
            }
            cur = cur.next;
        }
        // 没找到 return null;
        return null;
    }

    public void removeAllKey(int key){
        if(this.head == null){
            return;
        }
        ListNode prev = this.head;
        ListNode cur = this.head.next;
        while(cur != null){
            if(cur.val == key){
                prev.next = cur.next;
                cur = cur.next;
            }else{
                prev = cur;
                cur = cur.next;
            }
        }
        if(this.head.val == key){
            head = head.next;
        }
    }

    public void clear(){
        this.head = null;
    }

}

public class IndexWrongfulException extends RuntimeException{
    public IndexWrongfulException() {
    }

    public IndexWrongfulException(String message) {
        super(message);
    }
}

public class Test {
    public static void main(String[] args) {
        MySingleList mySingleList = new MySingleList();
        mySingleList.addFirst(3);
        mySingleList.addFirst(2);
        mySingleList.addLast(4);
        mySingleList.addFirst(1);
        mySingleList.addLast(5);
        try{
            mySingleList.addIndex(2,6);
        }catch (IndexWrongfulException e){
            e.printStackTrace();
        }
        mySingleList.remove(6);
        mySingleList.addFirst(5);
        mySingleList.removeAllKey(5);
        mySingleList.display();
        System.out.println(mySingleList.size());
        System.out.println("=====================================================");
        mySingleList.clear();
        mySingleList.display();
    }
}

三、链表面试题

3.1 反转单链表

OJ链接

思路：（头插法）
在这里插入图片描述
代码：

    // 反转链表
    public ListNode reverseList() {
        if(head == null){
            return null;
        }
        ListNode cur = head.next;
        head.next = null;
        while(cur != null) {
            ListNode curNext = cur.next;
            cur.next = head;
            head = cur;
            cur = curNext;
        }
        return head;
    }

3.2 返回中间节点

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

思路：
我们可以先遍历一遍得到 size，然后第二遍再走 size/2 步即可。
但若要求只能遍历一遍呢？
这时我们可以使用快慢指针法：
在这里插入图片描述
代码：

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
}

注意：

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

这一行代码不能改变判断的先后顺序：
如果把 fast.next != null 放在前面，若 fast == null ，会发生空指针异常！！！

3.3 倒数第k个结点

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

思路：
我们可以先遍历一遍得到 size，然后第二遍再走 size - k 步即可。
但若要求只能遍历一遍呢？
这时我们可以使用快慢指针法：
在这里插入图片描述
注意：

  • 先判断k的合法性。
  • 时刻注意避免空指针异常！！！

代码：

public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if(k <= 0 || k > size(head)){
            return null;
        }
        if(head == null){
            return null;
        }
        ListNode slow = head;
        ListNode fast = head;
        while((k-1) != 0 && fast.next != null){
            fast = fast.next;
            k--;
        }
        while (fast.next != null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }

        public int size(ListNode head){
        int count = 0;
        ListNode cur = head;
        while(cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    }

}

=============================================================================
改进：
判断k的合法性时：

        if(k <= 0 || k > size(head)){

这样判断的话，size()方法会先遍历一遍链表，所以我们可以之后再判断上界：

        while((k-1) != 0){
            fast = fast.next;
            if(fast == null){
                return null;
            }
            k--;
        }

改进后代码：

public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if(k <= 0){
            return null;
        }
        if(head == null){
            return null;
        }
        ListNode slow = head;
        ListNode fast = head;
        while((k-1) != 0){
            fast = fast.next;
            if(fast == null){
                return null;
            }
            k--;
        }
        while (fast.next != null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

3.4 合并链表

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

思路：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
代码：

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode newHead= new ListNode();
        ListNode tmp = newHead;
        while(list1 != null && list2 != null){
            if(list1.val <= list2.val){
                tmp.next = list1;
                tmp = tmp.next;
                list1 = list1.next;
            }else{
                tmp.next = list2;
                tmp = tmp.next;
                list2 = list2.next;
            }
        }
        if(list1 != null){
            tmp.next = list1;
        }
        if(list2 != null){
            tmp.next = list2;
        }     
        return newHead.next;  
    }
}

3.5 以x分割链表

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

思路：
在这里插入图片描述
两个链表都设置头尾两个指针。
在这里插入图片描述
注意：

  • 时刻注意避免空指针异常！！！
  • 最后ae.next要置空啊！：ae.next = null;

代码：

public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        // write code here
        if(pHead == null){
            return null;
        }
        ListNode as = null;
        ListNode ae = null;
        ListNode bs = null;
        ListNode be = null;
        ListNode cur = pHead;
        // 遍历链表，当 cur == null 时遍历完成
        while(cur != null){
            if(cur.val < x){
                if(bs == null){     // 第一次插入节点
                    bs = cur;
                    be = cur;
                }else{
                    be.next = cur;
                    be = be.next;
                }
            }else{
                if(as == null){
                    as = cur;
                    ae = cur;
                }else{
                    ae.next = cur;
                    ae = ae.next;
                }
            }
            cur = cur.next;
        }
        if(bs == null){       // 第一个段 没有数据
            return as;
        }else{
            be.next = as;
            // 手动置空！
            if(ae != null){
                ae.next = null;
            }
            return bs;
        }
    }
}

3.6 链表的回文结构

OJ链接

思路： 将中间节点后的所有节点逆置，两边同时向中间走进行比较。
在这里插入图片描述

  • 用快慢指针法找到中间节点 slow 。
  • 用头插法进行后半段逆序：（下图是逆序后）
    在这里插入图片描述
    然后两边同时向中间走进行比较：
    在这里插入图片描述
    写完后提交代码，我们发现并不能通过，这是因为偶数个数节点情况下会出现问题！！！
    在这里插入图片描述
    各走两步后：
    在这里插入图片描述
    出现了错误！！！
    所以，在判断回文的代码中，我们需要加入：
    在这里插入图片描述
    代码：
public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        // write code here
        // null：不是回文
        if(A == null){
            return false;
        }
        // 一个节点：是回文
        if(A.next == null){
            return true;
        }

        // 找中间节点：
        ListNode slow = A;
        ListNode fast = A;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }

        // 开始反转后半链表：
        ListNode cur = slow.next;
        while(cur != null){
            ListNode curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }

        // 开始判断回文：
        ListNode head = A;
        while(head != slow){
            if(head.val != slow.val){
                return false;
            }
            // 偶数个数节点时需要判断：
            if(head.next == slow){
                return true;
            }
            head = head.next;
            slow = slow.next;
        }
        return true;
    }
}

3.7 相交链表

输入两个链表，找出它们的第一个公共结点。
OJ链接
在这里插入图片描述
思路：
链表相交后的长度一定相等，所以长度差即为相交前的长度差。
代码：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 1.求链表的长度
        ListNode pl = headA;  // pl要永远指向最长的链表
        ListNode ps = headB;  // ps要永远指向最短的链表
        int lenA = 0;
        while(pl != null){
            lenA++;
            pl = pl.next;
        }
        int lenB = 0;
        while(ps != null){
            lenB++;
            ps = ps.next;
        }
        // pl和ps再指回去！
        pl = headA;
        ps = headB;
        int len = lenA - lenB;
        if(len < 0){
            pl = headB;
            ps = headA;
            len = lenB - lenA;
        }
        // 这时，pl永远指向了最长的链表；ps要永远指向最短的链表
        // 2.让最长的链表 先走len步
        while(len != 0) {
            pl = pl.next;
            len--;
        }
        // 3. pl和ps 现在在相同的起始位置，同时往后走
        while(pl != ps){
            pl = pl.next;
            ps = ps.next;
        }
        // 走到这里pl和ps相等了，即相交？
        // 但也可能都是null啊，这样的话不叫相交：(但此判断可有可无)
        if(pl == null){
            return null;
        }
        return pl;
    }
}

在编译器测试时，我们怎么构造出两个相交链表呢？很简单：
比如：headB.next.next = headA.next.next;

3.8 判断是否有环

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

思路：
快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表其实位置开始运行，如果链表带环则一定会在环中相遇，否则快指针率先走到链表的末尾。
代码：

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast){
                return true;
            }
        }
        return false;
    }
}

【扩展问题】：

  • 为什么快指针每次走两步，慢指针走一步可以？
    假设链表带环，两个指针最后都会进入环，快指针先进环，慢指针后进环。当慢指针刚进环时，可能就和快指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度。此时，两个指针每移动一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情况，因此：在满指针走到一圈之前，快指针肯定是可以追上慢指针的，即相遇。
  • 快指针一次走3步，走4步，…n步行吗？
    在这里插入图片描述
    在编译器测试时，我们怎么构造出环呢？很简单：
    在这里插入图片描述

3.9 入环节点

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

  • 结论：
    让一个指针从链表起始位置开始遍历链表，同时让一个指针从判环时相遇点的位置开始绕环运行，两个指针都是每次均走一步，最终肯定会在入口点的位置相遇。
  • 证明：
    在这里插入图片描述

代码：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast){
                break;
            }
        }
		if(fast == null || fast.next == null){
            return null;
        }
        ListNode cur = head;
        while(cur != slow){
            cur = cur.next;
            slow = slow.next;
        }
        return cur;
    }
}
yyhgo_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
004--认识单链表
Zero摄氏度的博客
02-24 388
单链表的定义、应用，对单链表中节点的添加删除和查找等。
10，认识单链表及其操作
A_Walsh的博客
05-10 92
认识单链表及其操作 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。 单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 单向链表图示 表元素域elem用来存放具体的数据。 链接域next用来存放下一个节点的位置（python中的标识） 变量p指向链表的
单链表
nicexiangshuai的博客
10-27 7147
单链表的实现和二路合并采取链表形式的实现
无头节点的单链表
07-17
无头节点单链表的实现可是说是对C语言指针一个最直接、最...上传这些代码完全因为楼主确实想把自己学习过程中的遇到到一些问题和错误认识，以及一些经验共享出来，希望帮助那些和曾经的我一样充满迷茫困惑的同学朋友。
浅谈PHP链表数据结构(单链表)
10-22
本文详细介绍了PHP语言中单链表数据结构的基本概念和应用，内容涉及单链表的定义、特点、在内存中的分布形式以及如何用...通过本篇文章，读者可以了解到PHP在数据结构方面的一些基本应用，并对链表结构有更深入的认识。
数据结构 单链表操作（c语言）
11-21
单链表是计算机科学中一种基础且重要的数据结构，它由一系列节点组成，每个节点包含数据元素和...记得在编程过程中，要确保对内存管理（如使用`malloc()`分配和`free()`释放内存）有清晰的认识，以避免内存泄漏等问题。
单链表操作 数据结构 C语言
10-24
单链表是一种基础的数据结构，它在计算机科学中扮演着重要的角色。单链表由一系列节点组成，每个节点包含两部分：数据元素和指向下一个节点的指针...通过分析和修改这个小程序，可以进一步提升对数据结构和算法的认识。
C++单链表实现源码
02-09
// 网上关于这方面的挺多，由于自己以前上课没好好学数据结构，现在重新认识数据结构， // 以下是自己写的基于C++的双向循环链表的创建及其一些操作与实现(于VC下通过)，没用模板， // 也没用类，所以比较适合有一点...
阿里云服务器 篇七：服务器热备份/定时备份
最新发布
生活在别处
08-24 38
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 424
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 784
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 676
linux上datax 安装以及使用
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 563
@Transactional中使用线程锁导致了锁失效与解决方案
android apk 加固后的地图加载异常及重新签名
calivnBao的博客
08-20 261
android apk 加固后的地图加载异常及重新签名
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 122
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
微服务框架
Founder_Xiao_Xin的博客
08-20 795
在分布式系统中，服务可能失败导致雪崩，Hystrix 是防雪崩利器，具有服务降级、服务熔断、服务隔离、监控等防止雪崩的技术。服务降级：接口调用失败调用本地方法返回空。服务熔断：接口调用失败进入熔断方法返回错误信息。服务隔离：隔离服务之间相互影响。服务监控：记录服务调用的运行指标。在分布式系统中，一个业务因跨越不同数据库或不同微服务而包含多个子事务，要求所有子事务同时成功或失败，这就是分布式事务。例如某电商系统下单操作，需请求订单服务、账户服务、库存服务。
使用Java通过身份证号码匹配省市县名称的技术博客
weixin_41489908的博客
08-21 342
每日自动更新各类学习教程及工具下载合集​​在中国，身份证号码包含了持有人的出生地信息。通过解析身份证号码的前六位，我们可以获取对应的省、市、县（区）信息。在这篇博客中，我们将探讨如何使用Java代码来实现这一功能，并展示详细的代码示例和运行结果。
[笔记] hyperf event
BLOCKGOLD.E的博客
08-20 496
得益于组件的支撑，用户可以很方便的对以下事件进行监听。例如。接下来我们就实现一个记录SQL的监听器，来说一下怎么使用。首先我们定义好，实现接口并对类定义php/***//***/return [/***/if (!
单链表操作实现：创建、查找、插入与删除
"这篇资源是关于线性表的编程实践，特别...通过这样的编程练习，学习者可以深入理解数据结构中的基本操作，提高对链表特性的认识，以及如何通过代码实现这些操作，这对于后续的算法设计和复杂数据结构的学习至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yyhgo_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值