常见链表的设计

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

链表是非常常见的一种数据结构，尤其是在一些操作系统中。
链表常见的操作有插入节点、删除节点、访问节点等。
本文实现了单向链表、双向链表的设计，并提供了可直接运行的C++代码，此外还说明了使用C语言在实现上的差异

本文所使用的图取自代码随想录

链表类型

  • 单链表

    image-20240905164200397

  • 双向链表

    image-20240905164239651

  • 循环链表

    image-20240905164300885

链表的存储方式

各个节点分布在内存的不同地址空间上，通过指针串联在一起

单链表的定义

struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

链表的操作

  • 删除节点

    image-20240905164922557

  • 添加节点

    image-20240905164951835

与数组对比

插入/删除（时间复杂度）查询（时间复杂度）使用场景
数组O(n)O(1)数据量固定，频繁查询，较少增删
链表O(1)O(n)数据量不固定，频繁增删，较少查询

移除链表元素

struct node {
    int value;
    node *next;
    node(int x) : value(x), next(nullptr) {}
};

node *removeElement(node *head, int val){
    node *dummyHead = new node(0);
    dummyHead->next = head;
    node *cur = dummyHead;
    
    while(cur->next != NULL){
        if(cur->next->value == val){
            node *tmp = cur->next;
            cur->next = cur->next->next;
            delete tmp;
        }
        else{
            cur = cur->next;
        }
    }
    head = dummyHead->next;
    delete dummyHead;
    return head;
}

链表设计

class MyList{    
public:
	struct node{
        int value;
        node *next;
        node(int initValue):value(initValue), next(nullptr){}
    };    
    MyList(){
        _dummyHead = new node(0);
        _size = 0;
    }
    
    // 获取第index个结点的数值
    int get(int index){
        if(index > (_size-1) || index < 0){
            // throw out_of_range("index out of range!");
            cout << "index out of range!————return INT32_MAX = " << INT32_MAX << endl;
            return INT32_MAX;
        }
        node *cur = _dummyHead->next;
        while(index){
            cur = cur->next;
            index--;
        }
        return cur->value;
    }
    
    // 在链表最前面插入一个节点
    void addAtHead(int value){
        node *newNode = new node(value);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }
    
    // 在链表最后面插入一个元素
    void addAtTail(int value){
		node *newNode = new node(value);        
        
        node *cur = _dummyHead;
        while(cur->next != nullptr){
    		cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }
    
    // 在第index个节点之前插入一个节点
    void addAtIndex(int index, int value){
        if(index > _size){
            return;
        }
        if(index < 0){
            index = 0;
        }
        
        node *newNode = new node(value);
        node *cur = _dummyHead;
        while(index != 0){
            cur = cur->next;
            index--;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
    
    // 删除第index个节点
    void deleteAtIndex(int index){
        if(index < 0 || index >= _size){
            return;
        }
        
        node *cur = _dummyHead;
        while(index != 0){
            cur = cur->next;
            index--;
        }
        node *tmp = cur->next;
        cur->next = cur->next->next;
        
        delete tmp;
        tmp = nullptr;
        _size--;
    }
    
    // 打印链表
    void printList(){
        node *cur = _dummyHead;
        while(cur->next != nullptr){
            cout << cur->next->value;
            cur = cur->next;
            if(cur->next){
                cout << "->";
            }
        }
        cout << endl;
    }

private:
    int _size;
    node *_dummyHead;    
};

单独实现插入节点

struct node{
    int value;
    node *next;
    node(int initValue):value(initValue), next(nullptr){}
};
void addAtIndex(node *&head, int index, int value){
    node *dummyHead = new node(0);
    dummyHead->next = head;
    
	node *cur = dummyHead;

    int size = 0;    
    while(cur->next != nullptr){
        size++;
        cur = cur->next;
    }
    
    if(index < 0){
        index = 0;
    }
    if(index > size){
        delete dummyHead;
        cout << "index is invalid" << endl;
        return;
    }
    
    cur = dummyHead;
    while(index){
        cur = cur->next;
        index--;
    }
    node *newNode = new node(value);
    newNode->next = cur->next;
    cur->next = newNode;
    size++;
    
    head = dummyHead->next;
    delete dummyHead;
}

使用C语言实现，与C++基本一致，只不过我们要自己定义结点的创建函数，并且new/delete要对应转换为malloc/free

typedef struct node{
    int value;
    struct node *next;
}node;


node *createNode(int value){
    node *newNode = (node *)malloc(sizeof(struct node));
    newNode->value = value;
    newNode->next = NULL;
    return newNode;
}

void addAtIndex(node **head, int index, int value){
    node *dummyHead = createNode(0);
    dummyHead->next = *head;
    
    int size = 0;
    node *cur = dummyHead;
    while(cur->next != NULL){
        cur = cur->next;
        size++;
    }
    
    if(index < 0)index=0;
    if(index > size){
    	free(dummyHead);    
        return;
    }
    
    cur = dummyHead;
    while(index){
        cur = cur->next;
        index--;
    }
    node *newNode = createNode(value);
    newNode->next = cur->next;
    cur->next = newNode;
    
    *head = dummyHead->next;
    free(dummyHead);
}

双向链表设计

class MyDualList{    
public:
    struct node{
        int value;
        node *next;
        node *prev;
        node(int initValue):value(initValue), next(nullptr), prev(nullptr){}
    };
    
    MyDualList(){
        _dummyHead = new node(0);
        _dummyTail = new node(0);
        _size = 0;
        _dummyHead->next = _dummyTail;
        _dummyTail->prev = _dummyHead;
    }
    
    int get(int index){
        if(index < 0 || index >= _size){
            return -1;
        }
        node *cur = _dummyHead->next;
        while(index){
            cur = cur->next;
            index--;
        }
        return cur->value;
    }
    
    void addAtHead(int value){
        node *newNode = new node(value);
        newNode->next = _dummyHead->next;
        _dummyHead->next->prev = newNode; // 跟单链表一致，只是在指针换向时多考虑一个prev指针
        _dummyHead->next = newNode;
        newNode->prev = _dummyHead; //
        _size++;
    }
    
    void addAtTail(int value){
        node *newNode = new node(value);
        
        // 这里设计的双向链表，与单向链表相比，末尾节点会指向_dummyTail，基于此可以像单向链表一样写
        // 不过从另一个角度来说，我们的尾插可以看作在_dummyTail之前插入一个节点
        _dummyTail->prev->next = newNode;
        newNode->prev = _dummyTail->prev;
        newNode->next = _dummyTail;
        _dummyTail->prev = newNode;
        _size++;
    }
    
    void addAtIndex(int index, int value){
        if(index < 0)index=0;
        if(index > _size)return;
        
        node *cur = _dummyHead;
        while(index){
            cur = cur->next;
            index--;
        }
        node *newNode = new node(value);
        newNode->next = cur->next;
        cur->next->prev = newNode;
        cur->next = newNode;
        newNode->prev = cur;
        _size++;
    }
    
    void deleteAtIndex(int index){
        if(index < 0 || index >= _size)return;
		node *cur = _dummyHead;
        while(index){
            cur = cur->next;
            index--;
        }
        node *tmp = cur->next;
        cur->next = cur->next->next;
        cur->next->prev = cur;
        
        delete tmp;
        _size--;
    }
    
    void printListForward(){
        node *cur = _dummyHead;
        while(cur->next != _dummyTail){
            cout << cur->next->value;
            cur = cur->next;
            if(cur->next != _dummyTail){
                cout << "->";
            }
        }
        cout << endl;
    }
    void printListReverse(){
        node *cur = _dummyTail;
        while(cur->prev != _dummyHead){
            cout << cur->prev->value;
            cur = cur->prev;
            if(cur->prev != _dummyHead){
                cout << "<-";
            }
        }
        cout << endl;
    }    
private:
    int _size = 0;
    node *_dummyHead, *_dummyTail;    
};

测试部分

  • 函数测试——添加与移除链表元素

    /* C++ */
#include<iostream>
using namespace std;

struct node {
    int value;
    node *next;
    node(int x) : value(x), next(NULL) {}
};

void printList(node *head){
    node *dummyHead = new node(0);
    dummyHead->next = head;
    node *cur = dummyHead;
    while(cur->next){
        cout << cur->next->value;
        cur = cur->next;
        if(cur->next){
            cout << "->";
        }
    }
    cout << endl;
}

void removeElement(node *&head, int val){
    node *dummyHead = new node(0);
    dummyHead->next = head;
    node *cur = dummyHead;
    
    while(cur->next != NULL){
        if(cur->next->value == val){
            node *tmp = cur->next;
            cur->next = cur->next->next;
            delete tmp;
        }
        else{
            cur = cur->next;
        }
    }
    head = dummyHead->next;
    delete dummyHead;
}

void addAtIndex(node *&head, int index, int value){
    node *dummyHead = new node(0);
    dummyHead->next = head;
    
	node *cur = dummyHead;

    int size = 0;    
    while(cur->next != nullptr){
        size++;
        cur = cur->next;
    }
    
    if(index < 0){
        index = 0;
    }
    if(index > size){
        delete dummyHead;
        cout << "index is invalid" << endl;
        return;
    }
    
    cur = dummyHead;
    while(index){
        cur = cur->next;
        index--;
    }
    node *newNode = new node(value);
    newNode->next = cur->next;
    cur->next = newNode;
    size++;
    
    head = dummyHead->next;
    delete dummyHead;
    dummyHead = nullptr;
}

int main(void){
    node *head = new node(0);
    addAtIndex(head, 1, 1);
    addAtIndex(head, 2, 2);
    addAtIndex(head, 3, 3);
    addAtIndex(head, 4, 4);
    addAtIndex(head, 5, 5);
    cout << "the LinkedList is:" << endl;
    printList(head);
    removeElement(head, 2);
    printList(head);
    return 0;
}

image-20240906163301527

/* C */
#include<stdio.h>
#include<stdlib.h>

typedef struct node{
    int value;
    struct node *next;
}node;

node *createNode(int value){
    node *newNode = (node *)malloc(sizeof(struct node));
    newNode->value = value;
    newNode->next = NULL;
    return newNode;
}

void printList(node *head){
    node *dummyHead = createNode(0);
    dummyHead->next = head;
    node *cur = dummyHead;
    while(cur->next){
        printf("%d", cur->next->value);
        cur = cur->next;
        if(cur->next){
            printf("->");
        }
    }
    printf("\n");
}

void addAtIndex(node **head, int index, int value){
    node *dummyHead = createNode(0);
    dummyHead->next = *head;
    
    int size = 0;
    node *cur = dummyHead;
    while(cur->next != NULL){
        cur = cur->next;
        size++;
    }
    
    if(index < 0)index=0;
    if(index > size){
    	free(dummyHead);    
        return;
    }
    
    cur = dummyHead;
    while(index){
        cur = cur->next;
        index--;
    }
    node *newNode = createNode(value);
    newNode->next = cur->next;
    cur->next = newNode;
    
    *head = dummyHead->next;
    free(dummyHead);
}

void removeElement(node **head, int val){
    node *dummyHead = createNode(0);
    dummyHead->next = *head;
    node *cur = dummyHead;
    
    while(cur->next != NULL){
        if(cur->next->value == val){
            node *tmp = cur->next;
            cur->next = cur->next->next;
            free(tmp);
        }
        else{
            cur = cur->next;
        }
    }
    *head = dummyHead->next;
    free(dummyHead);
}

int main(void){
    node *head = createNode(0);
    addAtIndex(&head, 1, 1);
    addAtIndex(&head, 2, 2);
    addAtIndex(&head, 3, 3);
    addAtIndex(&head, 4, 4);
    addAtIndex(&head, 5, 5);
    printf("the LinkedList is:\n");
    printList(head);
    removeElement(&head, 0);
    printList(head);
    return 0;
}

image-20240906163424875

  • 链表设计测试

    #include<iostream>
using namespace std;

class MyList{    
public:
	struct node{
        int value;
        node *next;
        node(int initValue):value(initValue), next(nullptr){}
    };    
    MyList(){
        _dummyHead = new node(0);
        _size = 0;
    }
    
    // 获取第index个结点的数值
    int get(int index){
        if(index > (_size-1) || index < 0){
            // throw out_of_range("index out of range!");
            cout << "index out of range!————return INT32_MAX = " << INT32_MAX << endl;
            return INT32_MAX;
        }
        node *cur = _dummyHead->next;
        while(index){
            cur = cur->next;
            index--;
        }
        return cur->value;
    }
    
    // 在链表最前面插入一个节点
    void addAtHead(int value){
        node *newNode = new node(value);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }
    
    // 在链表最后面插入一个元素
    void addAtTail(int value){
		node *newNode = new node(value);        
        
        node *cur = _dummyHead;
        while(cur->next != nullptr){
    		cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }
    
    // 在第index个节点之前插入一个节点
    void addAtIndex(int index, int value){
        if(index > _size){
            return;
        }
        if(index < 0){
            index = 0;
        }
        
        node *newNode = new node(value);
        node *cur = _dummyHead;
        while(index != 0){
            cur = cur->next;
            index--;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
    
    // 删除第index个节点
    void deleteAtIndex(int index){
        if(index < 0 || index >= _size){
            return;
        }
        
        node *cur = _dummyHead;
        while(index != 0){
            cur = cur->next;
            index--;
        }
        node *tmp = cur->next;
        cur->next = cur->next->next;
        
        delete tmp;
        tmp = nullptr;
        _size--;
    }
    
    // 打印链表
    void printList(){
        node *cur = _dummyHead;
        while(cur->next != nullptr){
            cout << cur->next->value;
            cur = cur->next;
            if(cur->next){
                cout << "->";
            }
        }
        cout << endl;
    }

private:
    int _size;
    node *_dummyHead;    
};

int main(){
    MyList list;
    list.addAtIndex(0,0);
    list.addAtIndex(1,1);
    list.addAtIndex(2,2);
    list.addAtIndex(3,3);
    list.addAtIndex(4,3);
    list.addAtIndex(5,4);
    list.printList();
    list.deleteAtIndex(3);
    list.printList();
    cout << list.get(1) << endl;
    return 0;
}

image-20240906163634682

  • 双向链表设计测试

    #include<iostream>
using namespace std;

class MyDualList{    
public:
    struct node{
        int value;
        node *next;
        node *prev;
        node(int initValue):value(initValue), next(nullptr), prev(nullptr){}
    };
    
    MyDualList(){
        _dummyHead = new node(0);
        _dummyTail = new node(0);
        _size = 0;
        _dummyHead->next = _dummyTail;
        _dummyTail->prev = _dummyHead;
    }
    
    int get(int index){
        if(index < 0 || index >= _size){
            return -1;
        }
        node *cur = _dummyHead->next;
        while(index){
            cur = cur->next;
            index--;
        }
        return cur->value;
    }
    
    void addAtHead(int value){
        node *newNode = new node(value);
        newNode->next = _dummyHead->next;
        _dummyHead->next->prev = newNode; // 跟单链表一致，只是在指针换向时多考虑一个prev指针
        _dummyHead->next = newNode;
        newNode->prev = _dummyHead; //
        _size++;
    }
    
    void addAtTail(int value){
        node *newNode = new node(value);
        
        // 这里设计的双向链表，与单向链表相比，末尾节点会指向_dummyTail，基于此可以像单向链表一样写
        // 不过从另一个角度来说，我们的尾插可以看作在_dummyTail之前插入一个节点
        _dummyTail->prev->next = newNode;
        newNode->prev = _dummyTail->prev;
        newNode->next = _dummyTail;
        _dummyTail->prev = newNode;
        _size++;
    }
    
    void addAtIndex(int index, int value){
        if(index < 0)index=0;
        if(index > _size)return;
        
        node *cur = _dummyHead;
        while(index){
            cur = cur->next;
            index--;
        }
        node *newNode = new node(value);
        newNode->next = cur->next;
        cur->next->prev = newNode;
        cur->next = newNode;
        newNode->prev = cur;
        _size++;
    }
    
    void deleteAtIndex(int index){
        if(index < 0 || index >= _size)return;
		node *cur = _dummyHead;
        while(index){
            cur = cur->next;
            index--;
        }
        node *tmp = cur->next;
        cur->next = cur->next->next;
        cur->next->prev = cur;
        
        delete tmp;
        _size--;
    }
    
    void printListForward(){
        node *cur = _dummyHead;
        while(cur->next != _dummyTail){
            cout << cur->next->value;
            cur = cur->next;
            if(cur->next != _dummyTail){
                cout << "->";
            }
        }
        cout << endl;
    }
    void printListReverse(){
        node *cur = _dummyTail;
        while(cur->prev != _dummyHead){
            cout << cur->prev->value;
            cur = cur->prev;
            if(cur->prev != _dummyHead){
                cout << "<-";
            }
        }
        cout << endl;
    }    
private:
    int _size = 0;
    node *_dummyHead, *_dummyTail;    
};

int main(){
    MyDualList list;
    list.addAtIndex(0,0);
    list.addAtIndex(1,1);
    list.addAtIndex(2,2);
    list.addAtIndex(3,3);
    list.addAtIndex(4,3);
    list.addAtIndex(5,4);
    list.addAtTail(60);
    list.printListForward();
    list.printListReverse();
    list.deleteAtIndex(3);
    list.printListForward();
    list.printListReverse();
    cout << list.get(1) << endl;
    return 0;
}

image-20240906163742188

StarLight~
关注
深入解析C++的循环链表与双向链表设计的API实现
09-02
总结起来，循环链表和双向链表在C++中是强大的数据结构，它们的API设计需要考虑各种常见的操作，如创建、销毁、插入、删除以及游标管理。理解并能熟练运用这些API对于解决实际问题，尤其是那些涉及到动态数据集合的...
C语言程序设计实训 基于链表的学生信息管理系统
07-18
在C语言编程世界中，学生信息管理系统是一个常见的项目，它能帮助我们理解数据结构、文件操作以及程序设计的基本原理。本实训项目主要利用C语言和C++技术，通过链表这一核心数据结构，实现了对学生信息的高效管理，...
链表的设计
qq_43666632的博客
09-09 767
链表的设计与实现
常见链表结构
Unknownfuture的博客
01-19 692
线性表，有顺序存储结构 和 链式存储结构两种,常见实现为一维数组和单链表。 性能对比 查找 插入和删除 顺序：O（1） 顺序：O（n） 单链表：O（n） 单链表：O（1） 显然，顺序存储结构适用于查找，链式存储结构适合于插入和删除操作，各有优缺点。 上述两种都比较简单，实现本文不介绍，略提一下优缺点。 接下来介绍其他的链表结构 静态链表 用数组描述的链表叫做静态链表。 关键...
常见的链表问题总结
LXYDSF的博客
11-06 864
常见的链表问题总结 无法高效获取长度，无法根据偏移快速访问元素，是链表的两个劣势。然而面试的时候经常碰见诸如获取倒数第k个元素，获取中间位置的元素，判断链表是否存在环，判断环的长度等和长度与位置有关的问题。这些问题都可以通过灵活运用双指针来解决。 Tips：双指针并不是固定的公式，而是一种思维方式~ 1.倒数第k个元素的问题 设有两个指针 p 和 q，初始时均指向头结点。首先，先让 p 沿着 next 移动 k 次。此时，p 指向第 k+1个结点，q 指向头节点，两个指针的距离为 k 。然后，同时移动 p
链表常见面试题
艾小方的博客
10-25 1058
链表面试题 文章目录链表面试题前言一、 删除链表中等于给定值 val 的所有节点。二、反转一个单链表。三、给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。四、输入一个链表，输出该链表中倒数第k个结点。五、 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。六、 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 。七、 链表的回文结构。八、 两个链表相交问题九、 链
链表&设计链表
weixin_42178081的博客
02-24 389
链表是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针。由于不必须按顺序存储，链表在插入的时候可以达到O(1)复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。
链表常见思路
weixin_50203536的博客
01-21 231
一：单链表 1：单链表反转 //单链表反转 public static Node reverseLinked(Node head){ if(head==null||head.next==null){ return head; } Node pre =null; Node next = null; while(head!=null){ next = head.next;
数据结构 09-链表概念及常见链表结构
一分耕耘一分收获
06-07 894
链表概念 前面提到，栈、队列都可以视作是一种特殊的线性表，在绝大多数语言中都是连续存储的。而链表则是不连续的存储方式，自适应内存大小，通过指针的使用，灵活将不同的内存块联系起来，实现动态增加动态删除。 链表的基础是结点 node，每个结点应该包含至少两个区域，一个是存放数据的区域，一个是指向下一个节点的指针。对于整个链表而言，应该有指向头结点的头指针，尾部结点根据链表的不同类型可以指向空（单链表），也可以指向头节点（循环链表）。根据指针的配置，结点可以是单向的，也可以是双向...
C语言链表常见代码
Malenficent的博客
12-15 706
#include<stdio.h> #include<stdlb.h> typedef struct _node{ int value; struct _node *next; }Node; typedef struct _list{ Node *head; Node *tail; }List; //用自己定义的数据结构代表整个链表 void add(List *pList,number) //链表的添加 { //add to the link-list Nod
707.设计链表
tyb333333的博客
08-21 623
可以说这五个接口，已经覆盖了链表的常见操作，是练习链表操作非常好的一道题目。下面采用的设置一个虚拟头结点（这样更方便一些，大家看代码就会感受出来）。
整数链表
07-11
在教学环境中，整数链表是计算机科学入门课程中常见的数据结构练习，帮助学生理解链式存储和动态内存管理的基本概念。通过完成整数链表的作业，学生可以更好地掌握这些核心概念，并为学习更复杂的算法和数据结构打下...
合并链表_合并链表_
10-03
合并链表是一个常见的数据结构问题，它涉及到对链表的操作，特别是涉及排序和连接操作。在本场景中，我们有两个非递减有序的链表A和B，目标是创建一个新的链表C，这个新链表C同样是非递减有序的。下面我们将详细探讨...
程序设计-建立我的班级链表.pptx
11-06
在程序设计领域，链表是一种常见的数据结构，与数组相比，它提供了更加灵活的数据存储方式。本主题将探讨如何建立一个班级链表，包括链表的基本概念、链表的结构以及如何通过编程实现链表的构建。 链表的核心特征...
数据结构编程实践20讲(Python版)—06二叉搜索树
AnFany
10-08 1140
数据结构编程实践20讲(Python版)—06二叉搜索树
每日学习一个数据结构-树
wendao76的专栏
10-03 1156
树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。在非空树中，有且仅有一个特定的节点被称为根（root），其余节点可分为m（m>0）个互不相交的有限集T1, T2, …, Tm，其中每一个集合本身又是一棵树，并且被称为根的子树（Subtree）。访问时机：三种遍历方式的主要区别在于访问根节点的时机不同。在前序遍历中，根节点在左、右子节点之前被访问；在中序遍历中，根节点在左、右子节点之间被访问；在后序遍历中，根节点在左、右子节点之后被访问。应用场景。
逆变器PQ控制模型、逆变器并网模型（Simulink） 直流侧电压650V～2000V均可 交流测电压为380V 有功功率和无功
10-10
逆变器PQ控制模型、逆变器并网模型（Simulink） 直流侧电压650V～2000V均可 交流测电压为380V 有功功率和无功功率可达10kW或10kVar，甚至更高
SpringBoot+Vue工厂生产设备维护管理系统答辩PPT.ppt
最新发布
10-10
计算机毕业设计答辩PPT
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值