java实现的无头单向非循环链表

最新推荐文章于 2024-11-12 21:14:07 发布
最新推荐文章于 2024-11-12 21:14:07 发布
阅读量953 收藏 15
点赞数 9
分类专栏： 数据结构 Java 文章标签： java 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_76124988/article/details/142423803
版权

java实现的无头单向非循环链表

ArrayList的缺陷

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

链表

链表的概念及结构

链表是一种物理存储结构上非连续的存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。在这里插入图片描述
链式结构在逻辑上是连续的，但是在物理上不一定连续，现实中的结点一般是从堆上申请出来的，从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

  1. 单向或者双向
    在这里插入图片描述

  2. 带头或者不带头
    在这里插入图片描述

  3. 循环或者非循环

在这里插入图片描述
所以有八种链表结构
单向带头循环链表，双向带头循环链表
单向不带头循环链表，双向不带头循环链表
单向带头非循环链表，双向带头非循环链表
单向不带头非循环链表，双向不带头非循环链表
虽然有这么多的链表的结构，重点需要我们掌握两种：

  • 无头单向非循环链表：结构简单，一般不会单独用来存数据，实际中更多是作为其他数据结构的子结构，如哈希，图的邻接表等等
  • 无头双向链表：在java的集合框架中LinkedList底层实现就是无头双向循环链表。

无头单向非循环链表的实现

public interface IList {
    //头插法
    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 clear();
    public void display();
}

public class MySingleList implements IList{

    //静态内部类创建节点
    static class LinkNode{
        public int value;
        public LinkNode next;

        public LinkNode(int value) {
            this.value = value;
        }
    }

    public LinkNode head;

    @Override
    public void addFirst(int data) {

    }

    @Override
    public void addLast(int data) {

    }

    @Override
    public void addIndex(int index, int data) {

    }

    @Override
    public boolean contains(int key) {
        return false;
    }

    @Override
    public void remove(int key) {

    }

    @Override
    public void removeAllKey(int key) {

    }

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

    @Override
    public void clear() {

    }

    @Override
    public void display() {

    }
}

我们先从打印链表开始，如果我们使用head引用来遍历打印，直到遇到null，到最后head到了null，我们就找不到头节点了，所以我们可以另外使用一个cur引用来遍历。

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

我们可以通过自己手动创建链表，来测试我们的打印链表方法

public void createSingleLink(){
    LinkNode node0 = new LinkNode(12);
    LinkNode node1 = new LinkNode(23);
    LinkNode node2 = new LinkNode(34);
    LinkNode node3 = new LinkNode(45);
    LinkNode node4 = new LinkNode(56);

    this.head = node0;
    node0.next = node1;
    node1.next = node2;
    node2.next = node3;
    node3.next = node4;
    node4.next = null;
}

public class Test {
    public static void main(String[] args) {
        MySingleList list = new MySingleList();
        list.createSingleLink();
        list.display();
    }
    //结果为：12 23 34 45 56 
}

接下来实现size()求链表节点个数，依然通过一个cur来遍历并计数。

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

public class Test {
    public static void main(String[] args) {
        MySingleList list = new MySingleList();
        list.createSingleLink();
        System.out.println(list.size());
    }
    //结果为：5
}

接下来实现查找是否包含关键字key是否在单链表当中的方法，我们依然通过遍历找到该key，返回true，找不到返回false

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

public class Test {
    public static void main(String[] args) {
        MySingleList list = new MySingleList();
        list.createSingleLink();
        //12 23 34 45 56
        System.out.println(list.contains(12));
        System.out.println(list.contains(34));
        System.out.println(list.contains(56));
        System.out.println(list.contains(100));
    }
    //结果为：true
    //true
    //true
    //false
}

接下来实现头插法，也就是在链表头部插入节点
在这里插入图片描述

@Override
public void addFirst(int data) {
    LinkNode newNode = new LinkNode(data);
    newNode.next = this.head;
    this.head = newNode;
}

public class Test {
    public static void main(String[] args) {
        MySingleList list1 = new MySingleList();
        list1.createSingleLink();
        list1.addFirst(99);
        list1.display();
        MySingleList list = new MySingleList();
        list.addFirst(56);
        list.addFirst(45);
        list.addFirst(34);
        list.addFirst(23);
        list.addFirst(12);
        list.addFirst(99);
        list.display();
    }
    //结果为：
    //99 12 23 34 45 56
    //99 12 23 34 45 56
}

接下来实现尾插法，我们需要先找到尾节点，再进行插入，还有我们还要考虑到如果链表为空时，代码是否能执行，是否需要我们再对其另外的实现
在这里插入图片描述
在这里插入图片描述

@Override
public void addLast(int data) {
    LinkNode newNode = new LinkNode(data);
    //如果链表为空
    if(this.head == null){
        this.head = newNode;       //直接将head指向新结点
        return;
    }
    //链表非空
    //首先找到尾结点
    LinkNode cur = this.head;
    while(cur.next != null){    //当cur走到尾结点，cur.next == null退出循环，cur指向尾结点
        cur = cur.next;
    }
    cur.next = newNode;
}

public class Test {
    public static void main(String[] args) {
        MySingleList list = new MySingleList();
        list.addLast(12);
        list.addLast(23);
        list.addLast(34);
        list.addLast(45);
        list.addLast(56);
        list.addLast(99);
        list.display();
    }
    //结果为：
    //12 23 34 45 56 99
}

接下来实现任意位置插入的方法,第一个数据节点为0号下标，任意位置插入涉及尾插，头插，还有中间插入，中间插入需要修改前后指向，所以需要找到插入位置的前一个，就可以实现互相绑定，而且绑定有一个规律：所有的绑定，优先绑定后面。如果优先绑定前面，可能会出现问题，例如该方法。还有我们要考虑到任意位置，是所有位置吗，我们还需要对index进行检查，不能小于0，也不能大于size();
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
如果先绑定前面会出现什么问题呢？
在这里插入图片描述

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

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

private void checkIndex(int index) throws IndexIllegal{
    if(index < 0 || index > size()){
        throw new IndexIllegal("插入位置不合法");
    }
}

@Override
public void addIndex(int index, int data) {
    try{
        checkIndex(index);
        int len = size();   //用一个变量存储就不用一直调用方法
        if(index == 0){
            addFirst(data);
            return;
        }
        if(index == len){
            addLast(data);
            return;
        }
        LinkNode newNode = new LinkNode(data);
        LinkNode cur = this.head;
        while(index - 1 != 0){
            cur = cur.next;
            index--;
        }
        newNode.next = cur.next;
        cur.next = newNode;
    }catch(IndexIllegal e){
        e.printStackTrace();
    }

}

public class Test {
    public static void main(String[] args) {
        MySingleList list = new MySingleList();
        list.addLast(12);
        list.addLast(23);
        list.addLast(34);
        list.addLast(45);
        list.addLast(56);
        list.display();
        list.addIndex(0,11);
        list.display();
        list.addIndex(6,66);
        list.display();
        list.addIndex(3,33);
        list.display();
        //list.addIndex(100,77);
    }
    //结果为：
    //12 23 34 45 56
    //11 12 23 34 45 56
    //11 12 23 34 45 56 66
    //11 12 23 33 34 45 56 66
}

接下来实现删除第一次出现关键字为key的节点的方法
在这里插入图片描述

在这里插入图片描述

@Override
public void remove(int key) {
    if(this.head == null){
        return;
    }
    if(this.head.value == key){
        this.head = this.head.next;
        return;
    }
    LinkNode cur = this.head;
    while(cur.next != null){
        if(cur.next.value == key){
            LinkNode del = cur.next;
            cur.next = del.next;    //也可以写成 cur.next = cur.next.next;
            return;
        }
        cur = cur.next;
    }
}

public class Test {
    public static void main(String[] args) {
        MySingleList list = new MySingleList();
        list.addLast(12);
        list.addLast(23);
        list.addLast(34);
        list.addLast(45);
        list.addLast(56);
        list.display();
        list.remove(12);
        list.display();
        list.remove(56);
        list.display();
        list.remove(34);
        list.display();
    }
    //结果为：
    //12 23 34 45 56 
    //23 34 45 56 
    //23 34 45 
    //23 45 
}

接下来实现删除所有值为key的节点的方法
在这里插入图片描述
在这里插入图片描述

@Override
public void removeAllKey(int key) {
    //如果链表为空，不能删
    if(this.head == null){
        return;
    }
    LinkNode prev = this.head;
    LinkNode cur = this.head.next;
    while(cur != null){
        if(cur.value == key){
            prev.next = cur.next;
            cur = cur.next;
        }else{
            prev = cur;
            cur = cur.next;
        }
    }
    if(this.head.value == key){
        this.head = this.head.next;
    }
}

public class Test {
    public static void main(String[] args) {
        MySingleList list = new MySingleList();
        list.addLast(23);
        list.addLast(23);
        list.addLast(34);
        list.addLast(23);
        list.addLast(56);
        list.display();
        list.removeAllKey(23);
        list.display();
    }
    //结果为：
    //23 23 34 23 56 
    //34 56
}

最后我们要实现的是清空链表
在这里插入图片描述

@Override
public void clear() {
    LinkNode cur = this.head;
    while(cur != null){
        LinkNode curN = cur.next;
        cur.next = null;
        cur = curN;
    }
    this.head = null;
}

public class Test {
    public static void main(String[] args) {
        MySingleList list = new MySingleList();
        list.addLast(23);
        list.addLast(23);
        list.addLast(34);
        list.addLast(23);
        list.addLast(56);
        list.display();
        list.clear();
        list.display();
    }
    //结果为：
    //23 23 34 23 56
    //
}

链表OJ题

  1. 反转一个单链表。 链接
    给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * 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; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null){
            return head;
        }
        ListNode cur = head.next;
        head.next = null;
        while(cur != null){
            ListNode curN = cur.next;
            cur.next = head;
            head = cur;
            cur = curN;
        }
        return head;

    }
}
  1. 给定一个带有头结点head的非空链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。 链接
    给你单链表的头结点 head ，请你找出并返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * 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; }
 * }
 */
class Solution {
    public ListNode middleNode(ListNode head) {
    	if(head == null){
            return head;
        }
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
}
  1. 输入一个链表，输出该链表中倒数第k个节点。 链接
    实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。
    说明：给定的 k 保证是有效的。
    在这里插入图片描述
    在这里插入图片描述
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int kthToLast(ListNode head, int k) {
        if(head == null){
            return -1;
        }
        if(k < 0){
            return -1;
        }
        //需要求长度
        // if(k > 5){
        //     return -1;
        // }
        ListNode slow = head;
        ListNode fast = head;
        while(k - 1 != 0){
            fast = fast.next;
            if(fast == null){
                return -1;
            }
            k--;
        }
        while(fast.next != null){
            fast = fast.next;
            slow = slow.next;
        }
        return slow.val;
    }
}
  1. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。链接
    将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
    在这里插入图片描述
    在这里插入图片描述
/**
 * Definition for singly-linked list.
 * 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; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1 == null){
            return list2;
        }
        if(list2 == null){
            return list1;
        }
        ListNode newH = new ListNode(-1);
        ListNode tmp = newH;
        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 newH.next;
    }
}
  1. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 。链接
    现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。
    在这里插入图片描述
    在这里插入图片描述
import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        // write code here
        ListNode cur = pHead;
        ListNode beforeBegin = null;
        ListNode beforeEnd = null;
        ListNode afterBegin = null;
        ListNode afterEnd = null;
        while(cur != null){
            if(cur.val < x){
                if(beforeBegin == null){
                    beforeBegin = beforeEnd = cur;
                }else{
                    beforeEnd.next = cur;
                    beforeEnd = beforeEnd.next;
                }
            }else{
                if(afterBegin == null){
                    afterBegin = afterEnd = cur;
                }else{
                    afterEnd.next = cur;
                    afterEnd = afterEnd.next;
                }
            }
            cur = cur.next;
        }
        if(beforeBegin == null){
            return afterBegin;
        }
        beforeEnd.next = afterBegin;
        if(afterEnd != null){
            afterEnd.next = null;
        }
        return beforeBegin;
    }
}
  1. 链表的回文结构。
    对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。
    给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。
    链接
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        // write code here
        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 curN = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curN;
        }
        fast = A;
        while(fast != slow){
            if(slow.val != fast.val){
                return false;
            }
            if(fast.next == slow){
                return true;
            }
            slow = slow.next;
            fast = fast.next;
        }
        return true;
    }
}
  1. 输入两个链表，找出它们的第一个公共结点。链接
    给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：

在这里插入图片描述

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode pLong = headA;
        ListNode pShort = headB;
        int lenA = 0;
        int lenB = 0;
        while(pLong != null){
            lenA++;
            pLong = pLong.next;
        }
        while(pShort != null){
            lenB++;
            pShort = pShort.next;
        }
        pLong = headA;
        pShort = headB;
        int len = lenA - lenB;
        if(len < 0){
            pLong = headB;
            pShort = headA;
            len = lenB - lenA;
        }
        while(len != 0){
            pLong = pLong.next;
            len--;
        }
        while(pLong != pShort){
            pLong = pLong.next;
            pShort = pShort.next;
        }
        if(pLong == null){
            return null;    //没相交
        }
        return pLong;
    }
}
  1. 给定一个链表，判断链表中是否有环。链接
    给你一个链表的头节点 head ，判断链表中是否有环。
    如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
    如果链表中存在环 ，则返回 true 。 否则，返回 false 。
    在这里插入图片描述
    思路：快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表起始位置开始运行，如果链表带环则一定会在环中相遇，否则快指针率先走到链表是末尾。
  • 为什么指针每次走两步，慢指针走一步可以？
    假设链表带环，两个指针最后都会进入环，快指针先进环，慢指针后进环，当慢指针刚进环时，可能就和快指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度，此时两个指针每移动一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情况，因此：在慢指针走到一圈之前，快指针肯定是可以追上慢指针的，即相遇。
  • 快指针一次走3步，走4步，…n步行吗？
    在这里插入图片描述
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    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;
    }
}
  1. 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 NULL。链接
    给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
    如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
    不允许修改链表。
    示例 1：
    在这里插入图片描述
    输入：head = [3,2,0,-4], pos = 1
    输出：返回索引为 1 的链表节点
    解释：链表中有一个环，其尾部连接到第二个节点。
    示例 2：
    在这里插入图片描述
    输入：head = [1], pos = -1
    输出：返回 null
    解释：链表中没有环。
    在这里插入图片描述
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    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;
            }
        }
        if(fast == null  || fast.next == null){
            return null;
        }
        slow = head;
        while(slow != fast){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

对于无头单向非循环链表就学习到这了，希望这篇文章对你有帮助。

running up that hill
关注
专栏目录
Python实现-无头单向非循环链表
12-22
无头单向非循环链表链表 无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等 无头单向非循环链表 对于任意一个数据元素a(i)来说，储存本身的...
算法：java实现无头单向非循环链表
OceanStar的博客
05-07 553
// 无头单链表 public class Singlelist { //链表可以没有头结点，不能没有头指针 private Node top; // 这里的top相当于第一个节点 private Node tail; // 用于尾部插入元素: 相当于最后一个车厢 private int length = 0; public Singlelist() ...
使用Java实现无头双向链表
08-03
这段代码实现了一个无头双向链表（Doubly Linked List）。无头双向链表是一种链表数据结构，其中每个节点不仅包含指向下一个节点的指针（`next`），还包含指向前一个节点的指针（`prev`）。这种结构使得链表在某些...
Java实现单向链表反转
08-27
Java实现单向链表反转 Java实现单向链表反转是指将单向链表的顺序颠倒，例如原链表为A->B->C->D->E->F，反转后变为F->E->D->C->B->A。这种操作在实际开发中非常有用，例如在数据处理、数据分析等领域。 单向链表...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 205
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
最新发布
kequanrrr的博客
11-12 146
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot 实现图片加水印
心猿意码
11-11 332
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 385
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 481
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 313
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA学习接口案例实例
shangan_3的博客
11-08 221
【代码】JAVA学习接口案例实例。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 1219
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
SpringMVC
hi_zf的博客
11-11 252
处理器映射器: HandlerMapping。处理器适配器: HandlerAdapter。视图解析器: ViewResolver。
ArkTS--应用状态
qq_63946637的博客
11-10 604
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
一文1800字使用Jmeter进行http接口性能测试！
MJH827的博客
11-12 193
接口测试是测试系统组件间接口的一种测试。接口测试主要用于检测外部系统与系统之间以及内部各个子系统之间的交互点。测试的重点是要检查数据的交换，传递和控制管理过程，以及系统间的相互逻辑依赖关系等。
MySQL 到 ClickHouse 数据同步优化（三）
Kami‘s home
11-08 882
CloudCanal 再次优化 MySQL 到 ClickHouse 数据链路，大幅提升数据同步性能，帮助业务快速构建实时数据分析环境。
JavaScript 高阶总结
qq_43787947的博客
11-11 525
JavaScript 高级总结
@ComponentScan注解引发外部请求无法处理的解决办法
Kwoky的博客
11-12 461
@ComponentScan注解引发外部请求无法处理的解决办法
JAVA循环链表操作详解与实现
"本文档主要介绍了在Java编程中操作循环链表的相关技术，包括单链表循环链表和双链表循环链表的实现。首先，我们回顾一下单链表和双链表的基本概念，以及它们的节点类和接口`ICommOperate<T>`，这些内容在之前的章节...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值