[牛客Hot101]链表篇

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量565 收藏
点赞数 1
分类专栏： 牛客网hot101 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54883034/article/details/129228445
版权

文章目录

1.翻转链表

在这里插入图片描述

❤️❤️ 算法思路： 设置一个指针pre，这个pre指向的是工作节点也就是在链表中挨个遍历的cur的前一个节点，初始的时候设置pre指向为null，因为要翻转链表，链表中的最后一个节点指向为null。逐个遍历链表中的每一个节点，每次遍历节点的前一个节点。curNext = cur.next 然后节点指定翻转当前节点指向前一个节点 cur.next = pre,然后更新pre的指向，指向为cur 即 pre = cur 然后工作节点cur 继续遍历链表的后续节点。

//翻转链表
public Node reverse(Node head){
    if(head == null || head.next == null){
        return head;
    }
    Node cur = head;
    Node curNext = null;
    Node pre = null;
    while (cur != null){
        //记录当前节点的后置节点
        curNext = cur.next;
        //当前节点的next指针指向前置节点，那么此时就实现了一个节点的翻转
        cur.next = pre;
        //前置节点指向更新
        pre = cur;
        //当前节点继续遍历
        cur = curNext;
    }
    //.最后cur 为空，pre是cur 的前置节点，那么此时的pre就是翻转后链表的头节点
    return pre;
}

2.链表内指定区间翻转

在这里插入图片描述

❤️❤️ 算法思路： 其实就是翻转链表的一个变种，翻转链表的一部分，找到翻转链表的头节点和尾节点，还有就是翻转链表头节点的前一个节点和翻转链表的最后一个节点的后一个节点。把部分链表翻转之后，进行拼接。
在这里插入图片描述

//翻转链表中的一部分
public Node reverseSub(Node head,int m,int n){
    if(head == null || head.next == null || m == n){
        return head;
    }
    Node dummy = new Node(-1);
    dummy.next = head;
    Node pre = dummy;
    //得到翻转链表的头节点的前一个节点
    for(int i = 0;i < m - 1;i++){
        pre = pre.next;
    }
    //翻转链表的最后一个节点
    Node rightNode = pre;
    for(int i = 0; i < n - m + 1;i++){
        rightNode = rightNode.next;
    }
    //翻转链表的头节点
    Node leftNode = pre.next;
    pre.next = null;

    System.out.println(rightNode.val);
    Node curNext = rightNode.next;
    rightNode.next = null;

    reverse(leftNode);
    pre.next = rightNode;
    leftNode.next = curNext;
    return dummy.next;
}

3. 链表中的节点每k个一组翻转

在这里插入图片描述

❤️❤️ 算法思路： 因为要翻转链表，那么我们可以联想到使用栈，栈是先进后出的，那么此时我们把节点添加到栈中，等到栈中添了k个节点之后，然后我们把这些节点依次从栈中取出来并且连接每个节点，那么这就反转了一组链表片段。如果在遍历链表的时候，如果这一组不够k个，那么我们就直接把剩下的几个节点添加到反转链表的末尾即可
在这里插入图片描述

public Node kCountsReverse(Node head,int k){
    if(head == null || head.next == null) {
        return head;
    }
    //使用栈，把链表中的节点压到栈中，进栈的时候，一边计数，如果此时的这个计数的结果等于k 那么就退出，把栈中的节点弹出来
    //并且连接在一起。如果不够k个一组，那么就直接拼到翻转链表的后面
    Stack<Node> stack = new Stack<>();
    Node dummy = new Node(-1);
    Node p = dummy;  //添加后续节点
    while(true){
        int count = 0;
        Node cur = head;
        while(cur != null && count != k){
            stack.push(cur);
            count++;
            cur = cur.next;
        }
        //如果不构成一组,但是此时cur == null
        if(count != k){
            //直接拼接
            p.next = head;
            break;
        }
        while(!stack.empty()){
            p.next = stack.pop();
            p = p.next;
        }
        p.next = cur;
        head = cur;
    }
    return dummy.next;
}

4. 合并两个排序的链表

在这里插入图片描述

❤️❤️ 算法思路： 首先判定先决条件如果在待排序的链表中，有一个链表为空，那么就直接返回另一个链表，如果两个链表都为空，那么就直接输出null。如果两个链表都不为空，那么就进行排序，设置一个虚拟节点dummy,然后设置一个连接链表的指针p,这个指针p用来遍历整个链表，起先这个指针p指向节点dummy.
在这里插入图片描述

public Node sort(Node head1,Node head2){
    if(head1 == null && head2 == null){
        return null;
    }
    if(head1 == null){
        return head2;
    }
    if(head2 == null){
        return head1;
    }
    Node dummy = new Node(-1);
    Node p = dummy;
    Node cur1 = head1;
    Node cur2 = head2;
    while(cur1 != null && cur2 != null){
        if(cur1.val <= cur2.val){
            p.next = cur1;
            cur1 = cur1.next;
        }else{
            p.next = cur2;
            cur2 = cur2.next;
        }
        p = p.next;
    }
    if(cur1 != null){
        p.next = cur1;
    }
    if(cur2 != null){
        p.next = cur2;
    }
    return dummy.next;
}

5. 合并k个排序的链表

两种方法，方法一使用归并排序，方法二:使用堆
在这里插入图片描述

❤️❤️算法思路方法一：使用归并排序思想，根据归并排序思想，我们把这k个链表一直分，一直分，分到 这个组合有两个链表，我们两个链表进行合并，然后再返回排序好的链表。总的来说就是先分后合。这里我们可以把每个链表看成一个元素，就是list之间进行分治然后在合并
在这里插入图片描述

public Node func(List<Node> list){
    if(list == null){
        return null;
    }
    return process(list,0,list.size() - 1);
}
public Node process(List<Node> list,int left,int right){
    if(left > right){
        return null;
    }else if(left == right){
        return list.get(left);
    }
    int mid = (left + right) >> 1; 
    Node head1 = process(list,left,mid);
    Node head2 = process(list,mid + 1,right);
    //调用上面我们写的排序两个已经排序好的链表中的那个题目的代码
    return sort(head1,head2);
}

❤️❤️**算法思路方法二：**使用优先队列。其实我们在题目中可以不进行指定创建出来的queue对象是小顶堆，其实创建出来的queue对象默认就是一个小顶堆。就是把这k个链表的头节点，都加到小顶堆中，让每个链表的头节点进行比较，在小顶堆中，值域较小的节点就在堆顶，然后我们创建出一个虚拟节点，用于来连接排序好的链表，还有设置指针p.如果小顶堆不为空，那么就的弹出小顶堆的堆顶元素，并且保存堆顶元素，使用指针p 连接弹出的这个节点，然后判断弹出的这个节点有没有后继节点，如果有就添加到小顶堆中。继续使用小顶堆，找出最小的节点，使用p指针，继续拼接
在这里插入图片描述

public Node func2(List<Node> list){
    if(list == null){
        return null;
    }
    PriorityQueue<Node> queue = new PriorityQueue<>((v1,v2)->(v1.val - v2.val));
    //把每个链表的头节点都加到小跟堆中
    for(int i = 0;i < list.size();i++){
        //如果k个链表中的头节点，不为空，那么就把这个节点添加到小跟堆中
        if(list.get(i) != null){
            queue.offer(list.get(i));
        }
    }
    Node dummy = new Node(-1);
    Node p = dummy;
    while(!queue.isEmpty()){
        //如果此时的小跟堆不为空，那么此时就弹出堆中最小的元素，也就是堆顶元素
        Node node = queue.poll();
        p.next = node;
        p = p.next;
        //如果堆顶元素在链表中还有下一个节点，那么就把下一个节点添加到小顶堆中，继续下一次比较
        if(node.next != null){
            queue.offer(node.next);
        }
    }
    return dummy.next;
}

6. 判断链表是否有环

在这里插入图片描述

❤️❤️算法思路： 其实这是一个非常经典的面试题，这个题目考察的是快慢指针，起初让快慢指针同时位于链表的头节点，然后遍历链表，让慢指针一次遍历一个节点，让快指针一次遍历两个节点(跳跃两个节点)，如果是环形链表，那么此时的快指针和慢指针一定会在某一个位置相遇

public boolean isCycle(Node head){
    if(head == null){
        return false;
    }
    if(head.next == null) {
        return true;
    }
    Node slow = head;
    Node fast = head;
    while(fast.next != null && fast.next.next != null){
        slow = slow.next;
        fast = fast.next.next;
        if(slow == fast){
            return true; 
        }
    }
    return false;
}

7. 链表中倒数第k个节点

在这里插入图片描述

❤️❤️算法思想： 设置两个指针，一个是快指针，一个是慢指针，先让快指针遍历k步，那么此时的慢指针和快指针之间就相差k个节点，那么此时让慢指针和快指针一块遍历链表，一次遍历一个节点，直到快指针指向的节点为null,那么此时的慢指针就指向了链表的倒数第k个节点

ublic Node func2(Node head,int k){
    //设置一个指针，先让这个快指针走k步，然后设置一个慢指针，快指针和慢指针一块走，知道快指针遍历到了null节点，
    //那么此时就找到了链表的倒数第k个节点
    Node slow = head;
    Node fast = head;
    int count = 0;
    while(count != k){
        if(fast != null){
            count++;
            fast = fast.next;
        }else{
            return null;
        }
    }
    while(fast != null){
        slow = slow.next;
        fast = fast.next;
    }
    return slow;
}

8. 删除链表中的倒数第k和节点

在这里插入图片描述

❤️❤️算法思路： 首先我们要设置一个虚拟节点，然后让这个虚拟节点的next指针指向头结点，因为在题目中有可能删除头结点。然后我们和上题是一样的设置两个指针，一个快指针，一个慢指针，快指针先遍历k步，因为我们最终要找到的是删除节点的前一个节点，然后让这前一个节点的next指针指向删除节点的后一个节点。所以此时我们的循环条件就由原来的fast != null 变成了 fast.next != null 这样快指针和慢指针一次走一步，然后直到fast.next == null 那么我们此时就找到了链表的倒数第k + 1 个节点，就是删除节点的前一个节点，然后它的next指针指向删除节点的后一个节点。
在这里插入图片描述

public Node func3(Node head,int k){
    if(head == null){
        return null;
    }
    Node dummy = new Node(-1);
    dummy.next = head;
    Node slow = dummy;
    Node fast = dummy;
    for(int i = 0;i < k;i++){
        fast = fast.next;
    }
    while(fast.next != null){
        slow = slow.next;
        fast = fast.next;
    }
    slow.next = slow.next.next;
    return dummy.next;
}

9. 两个链表的第一个公共节点

在这里插入图片描述

❤️❤️ 算法思路： 首先得到两个链表的长度，让长的链表减去短的链表的长度，得到的差值，让长链表走差值步，然后两个链表中的指着一步一个走，知道两个链表的节点重合

public Node func4(Node head1,Node head2){
    if(head1 == null || head2 == null){
        return null;
    }
    int count1 = getCount(head1);
    int count2 = getCount(head2);
    int num = Math.abs(count1 - count2);
    if(count1 > count2){
        while(num != 0){
            head1 = head1.next;
            num--;
        }
    }else{
        while(num != 0){
            head2 = head2.next;
            num--;
        }
    }
    while(head1 != head2){
        head1 = head1.next;
        head2 = head2.next;
    }
    return head1;
}

10.链表的入环节点

在这里插入图片描述

在这里插入图片描述

❤️❤️算法思想： 首先判断链表是否有环，如果链表是无环的，那么就不存在这个链表的入环节点，然后就是当快指针和慢指针走到一块的时候，此时就记住这个节点，然后让慢指针指向链表的头部，然后两个指针一块走，直到两个指针相遇。

public Node getCycle(Node head){
    Node slow = head;
    Node fast = head;
    while(fast.next != null && fast.next.next != null){
        slow = slow.next;
        fast = fast.next.next;
        if(slow == fast){
            return slow;
        }
    }
    return null;
}
public Node cycleNode(Node head){
    if(head == null || head.next == null){
        return null;
    }
    Node fast = getCycle(head);
    if(fast == null){
        return null;
    }
    Node slow = head;
    while(slow != fast){
        slow = slow.next;
        fast = fast.next;
    }
    return slow;
}

11. 链表相加（二）

在这里插入图片描述

❤️❤️算法思想： 其实就相当于是两个数字在相加，数字在相加的时候，是从个位开始相加的，那么我们此时只有把链表翻转之后，才能相加，并且在相加的时候要注意进位，相加完之后，得到翻转的结果之后，把链表进行翻转

public Node getSum(Node head1,Node head2){
    if(head1 == null && head2 == null){
        return null;
    }
    if(head1 == null){
        return head2;
    }
    if(head2 == null){
        return head1;
    }
    int carry = 0;
    //翻转链表
    Node newHead1 = reverse(head1);
    Node newHead2 = reverse(head2);
    Node dummy = new Node(-1);
    Node p = dummy;
    while(newHead1 != null || newHead2 != null){
        int sum = (newHead1 == null ? 0 : newHead1 .val) + (newHead2 == null ? 0 : newHead2.val) + carry;
        carry = sum >= 10 ? sum / 10 : 0;
        sum = sum >= 10 ? sum % 10 : sum;
        Node node = new Node(sum);
        p.next = node;
        p = p.next;
        newHead1 = newHead1 == null ? null : newHead1.next;
        newHead2 = newHead2 == null ? null : newHead2.next;
    }
    if(carry != 0){
        p.next = new Node(carry);
    }
    return reverse(dummy.next);
}

12. 单链表排序

在这里插入图片描述

❤️❤️算法思想： 其实这个题还是很简单的，我们可以改成归并排序，其实这个归并排序思想就是把链表从中间分开，每次都进行分，知道把链表分成单个的节点，然后在里用两个有序链表构成一个新的有序的大链表就行了。这个就是典型的归并排序。

public class Solution {
    /**
     * 
     * @param head ListNode类 the head node
     * @return ListNode类
     */
     public ListNode sortInList (ListNode head) {
         //保证时间复杂度为O(n * logn)
        if(head == null || head.next == null){
            return head;
        }
        //每次都断开中间节点
        ListNode temp = getMid(head);
        ListNode head1 = sortInList(head);
        ListNode head2 = sortInList(temp);
        return marge(head1,head2);
    }

    private ListNode marge(ListNode head1, ListNode head2) {
        ListNode dummy = new ListNode(-1);
        ListNode p = dummy;
        while(head1 != null && head2 != null){
            if(head1.val <= head2.val){
                p.next = head1;
                head1 = head1.next;
            } else{
                p.next = head2;
                 head2 = head2.next;
            }
            p = p.next;
        }
        if(head1 != null){
            p.next = head1;
        }
        if(head2 != null){
            p.next = head2;
        }
        return dummy.next;
    }

    private ListNode getMid(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while(fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode temp = slow.next;
        slow.next = null;
        return temp;
    }
}

13.判断一个链表是否是回文结构

在这里插入图片描述

❤️❤️算法思想：找到链表的中间节点，把中间节点之后的链表节点全部翻转，然后让一个指针指向链表的头节点，让一个指针指向翻转链表的头节点，然后两个指针一个向右遍历，一个向左遍历，在遍历的过程中判断，节点中的val值是否是相同的。

public class Solution {
    /**
     *
     * @param head ListNode类 the head
     * @return bool布尔型
     */
     private ListNode getMid(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while(fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
    //方法二翻转部分链表
    public boolean isPail (ListNode head) {
        if(head == null){
            return false;
        }
        //找到链表的中间节点
        ListNode preNewHead = getMid(head);
        ListNode newHead = preNewHead.next;
        preNewHead.next = null;
        ListNode cur = reverse(newHead);
        while(head != null && cur != null){
            if(head.val != cur.val){
                return false;
            }
            head = head.next;
            cur = cur.next;
        }
        return true;
    }
    private ListNode reverse(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null){
            ListNode curNext = cur.next;
            cur.next = pre;
            pre = cur;
            cur = curNext;
        }
        return pre;
    }
}

14. 链表的奇偶重排

在这里插入图片描述

❤️❤️算法思想： 首先呢，这是一种笨办法，我们把原链表中所有的全部节点添加到栈中，并且把每个节点之前的连接断开，在栈中添加节点的时候我们还要进行奇数，要知道在栈中得到了多少个节点，然后设置两个虚拟节点和两个遍历指针p1,p2，然后我们把栈中的节点弹出来根据此时的count判断此时这个是偶数位节点和时奇数位节点，然后拼好两个链表，然后把两个链表进行翻转，然后两个链表拼接。

public static Node func2(Node head){
    Stack<Node> stack = new Stack<>();
    Node dummy1 = new Node(-1);
    Node p1 = dummy1;
    Node dummy2 = new Node(-2);
    Node p2 = dummy2;
    Node cur = head;
    int count = 0;
    while(cur != null){
        Node curNext = cur.next;
        cur.next = null;
        stack.push(cur);
        count++;
        cur = curNext;
    }
    while(count != 0){
        //奇数
        if(count % 2 == 1){
            p1.next = stack.pop();
            p1 = p1.next;
        }else{
            //偶数
            p2.next = stack.pop();
            p2 = p2.next;
        }
        count--;
    }
    //因为此时的两个链表是有栈得到的，那么此时它们的排列顺序是不对的，那么此时我们把这两个链表进行翻转
    Node node1 = reverse(dummy1.next);
    Node node2 = reverse(dummy2.next);
    Node ret = node1;
   while(node1.next != null){
       node1 = node1.next;
   }
    //得到奇数链表的最后一个节点，和偶数链表的最后一个节点相连
   node1.next = node2;
    return ret;
}

15.删除有序链表中重复的元素I

在这里插入图片描述

❤️❤️算法思想：先判断该链表是不是一个空链表，如果是空链表，那么就直接返回null,如果该链表只有一个节点，那么就直接返回head。因为要删除相同的节点，并且保留重复节点中的一个节点，那现在就比如说，此时有 cur,cur.next这个两个指针指向的节点，这两个节点的值域中的val是一样的，那么此时我们就保留cur这个位置上的节点，删除cur.next这个指针指向的节点。判断当前节点和当前节点的下一个节点相同，那么此时我们就不在返回的链表上添加这个节点。

图示：
在这里插入图片描述

import java.util.*;
public class Solution {
    public ListNode deleteDuplicates (ListNode head) {
        //如果此时的头节点为空，或者是此时只有一个节点
        if(head == null || head.next == null){
            return head;
        }
        //设置虚拟节点，因为在删除元素的时候，可能会对于头节点有影响
        ListNode dummy = new ListNode(-1);
        ListNode p = dummy;
        ListNode cur = head;
        while(cur != null){
            //如果在遍历的时候遇到了相同的节点，那么此时就一直遍历，不在返回链表中插入新的节点
            if(cur.next != null && cur.val == cur.next.val){
                while(cur.next != null && cur.val == cur.next.val){
                    cur = cur.next;
                }
            }
            p.next = cur;
            cur = cur.next;
            p = p.next;
        }
        //dummy.next表示的是返回链表的头节点
        return dummy.next;
    }
}

16.删除有序链表中重复的元素||

在这里插入图片描述

❤️❤️算法思想：其实这道题是上一道题的一个延伸，就是把链表中重复的的节点都删除了。那么此时我们就把预先设置的虚拟节点，看做为要返回链表的头节点，令工作节点cur = dummy 判断cur.next 和 cur.next.next是不是相同的节点，然后记录一下这两个节点的值，在判断cur.next.next之后有没有相同的节点，如果有cur.next = cur.next.next.

图示：
在这里插入图片描述

import java.util.*;
public class Solution {
    public ListNode deleteDuplicates (ListNode head) {
        if(head == null || head.next == null){
            return head;
        }
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        dummy.next = head;
        while(cur.next != null && cur.next.next != null){
            if(cur.next.val == cur.next.next.val){
                int x = cur.next.val;
                while(cur.next != null && cur.next.val == x){
                    cur.next = cur.next.next;
                }
            }else{
                cur = cur.next;
            }
        }
        return dummy.next;
    }
}
小周学编程~~~
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
牛客面试算法top101（JAVA和C++）
04-30
牛客面试算法top101（JAVA和C++） 作为一名IT大师，我将为您提供详细的IT知识点，基于给定的文件信息。 标题解读 牛客面试算法top101（JAVA和C++）是指牛客网提供的面试算法题库中的top101道题，涵盖了JAVA和C++两...
关于牛客刷题总结全部汇总
02-21
关于牛客刷题总结全部汇总 本资源摘要信息主要讲述了 Java 语言的基本概念、设计模式、MVC 模式、数学函数、重载和重写的区别、多态、数组、静态成员和方法、事务属性等知识点。 一、Java 基本概念 1. Java 源...
牛客hot100--BM6---判断链表中是否有环(简单难度)
想要成为大佬的彪彪
03-10 363
目录题目概述(简单难度)思路与代码思路展现代码示例 题目概述(简单难度) 题目链接： 点我进入牛客网 思路与代码 思路展现 这道题目是我之前做过的一道题目，具体题解可以看我的这篇博客： 点我进入博客 代码示例 /** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; *
牛客Top100热题宝典--第1节
weixin_41171614的博客
03-26 732
牛客Top100热题宝典--第1节，链表，二分查找，折半查找
链表节点数字相加（牛客TOP101.BM11, 力扣HOT100.2）
m0_47743353的博客
12-05 180
链表节点数相加
LeetCode 热题 HOT 100【题型归类汇总，助力刷题】
梦~'
03-18 3675
LeetCode 热题 HOT 100🔥【题型归类汇总】，超详细，不断优化ing ...
剑指offer链表的题
weixin_41692832的博客
10-16 142
文章目录前情提要删除链表中重复的结点链表中倒数第k个结点复杂链表的复制从头到尾打印链表合并两个排序的链表反转链表链表中环的入口调整数组顺序使奇数位于偶数前面圆圈中最后剩下的数两个链表的第一个公共节点 前情提要 刚刷完牛客网的剑指offer，写个博客对自己的一个总结。第一次刷，很多题只会暴力破解，我把做每道题的个人思路和他人思路用java进行了编写，如果在这篇文章找不到可以试试看看别的区域，因为很多...
牛客秋招面经记录
XCSDNJ2713的博客
09-05 337
作者：lengxia链接：https://www.nowcoder.com/discuss/210571来源：牛客网 旷视凉面 lengxia 编辑于 今天 19.7.24 19:20:24 app内打开 赞 0 | 收藏 5 | 回复3 | 浏览626 ...
LeetCode Hot 100 --- 两数相加（java）
小样yx的博客
09-01 102
题目 代码 这题与之前写过的牛客Top200—链表相加，十分相似，只不过一个往右进位，一个往左进位 class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { int carry = 0; ListNode head = new ListNode(-1);//头结点 ListNode cur = head; while(l1 != null ||
秋招总结帖，还愿牛客
qq_36810219的博客
10-26 239
秋招总结帖 待完善，持续更新 小米（offer） 寒武纪（池子） 荣耀（二面挂） 华为（池子） 茄子科技（hr面后挂） 58 同城（意向） 经纬恒润（天津，n+2w） 海信（青岛，nw） XX（北京国企，有京户，nw） 神策数据（面试） 招银网络科技（一面鸽） 小红书（一面挂） 快手（一面挂） 字节跳动（一面挂） 百度（一面挂） oppo（一面挂） 龙湖科技（一面挂） 京东 美团 哔哩哔哩 拼多多 网易 携程 奇安信 虾皮 蔚来 知乎 图森 海量数据处理 可以全部放到内存：哈希表统计 不可以全部放到内存：
题解 | 牛客周赛 Round 47 CDEF Java题解
han_xue_feng的博客
06-18 1004
如题，本人四川非川大985毕业，gap一年申到港理硕士，本硕专业都是大数据人工智能相关，求职方向是数。40多分钟，凭记忆写一下static关键字作用-1的原码，反码，补码数组和链表的区别vector e。24应届 0 offer，想找个后端开发或者java，求佬痛批简历，顺便找找工作，大公司已经不敢奢求。想找个B端销售的工作来实习一下，从而丰富一下履历，我这简历真的没有什么写的 #实习，投递多份简历没人。不太清楚两个公司的发展情况，感觉都还不错。二选一，都是央企，本2硕9，女生，城市都在一线，软件专业。
牛客校招C++宝典.rar
03-17
- **数据结构**：链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）的基础知识。 4. **数据库知识**： - **关系型数据库理论**：理解ACID属性，了解范式理论。 - **SQL语言**：熟练使用SELECT查询、INSERT插入...
牛客刷题总结.docx
01-28
"牛客刷题总结" 本资源摘要信息主要涵盖了 Java 语言的基础知识点、设计模式和事务处理。下面是详细的知识点解释： 一、Java 基础知识 1. Java 源程序只能有一个 public 类存在，且类名与文件名相同。这是因为 ...
Java-Lambda
最新发布
lizhiwei21的博客
07-21 174
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 495
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1173
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1147
JVM-垃圾回收与内存分配
牛客面试算法TOP101：JAVA与C++解析
"牛客面试算法top101（JAVA和C++）提供了101个热门的算法题目，包括PDF和HTML格式，旨在帮助求职者准备面试。在NowCoder平台上可以找到相关的在线编程题目集，涵盖了算法分类，适合进行算法刷题。此资源可能包含从...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小周学编程~~~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值