王道考研--》单链表课后习题C语言代码实现（冲刺）

        考研是许多计算机科学专业学生追求高学历、寻求更好就业前景的途径。在考研过程中，数据结构是一个非常重要的科目，而代码实现题更是其中的难点之一。在这篇文章中，我们将探讨如何通过实现数据结构代码问题来提升考研成绩。无论您是否有编程经验，本文将为您提供一些简单但实用的技巧，帮助您应对考研中遇到的数据结构题目。让我们一起踏上这个挑战性的学习旅程吧！

目录

初识单链表

第一题）递归删除不带头节点链表中指定值

第二题）带头节点链表删除指定值

第三题）反向输出链表值

第四题） 带头节点的单链表删除最小值结点

第五题）求两链表交集

第六题）单链表排序

第七题）删除重复结点

第八题）删除绝对值相等的结点

初识单链表

        单链表是一种常见的基本数据结构，它由一系列节点组成，每个节点包含两部分：数据（即存储的元素）和指向下一个节点的引用（指针或链接）。单链表中的节点按照其在内存中的位置顺序连接起来，形成一个链式结构。

单链表中的第一个节点称为头节点，最后一个节点的指针部分指向一个空值（通常表示为 null），表示链表的结束。

单链表的特点：

1）动态性： 单链表的长度可以动态地增加或减少，不需要预先指定大小。

2）插入与删除高效： 在单链表中，插入或删除元素时只需要修改节点之间的指针，时间复杂度为 O(1)。

3）随机访问效率低： 与数组不同，单链表中的元素并不是在连续的内存空间中存储的，因此难以通过索引进行快速访问，需要从头节点开始按顺序遍历，时间复杂度为 O(n)。

实现单链表通常包括以下步骤(C语言实现)：

1）定义节点结构体：
首先，需要定义一个结构体来表示链表的节点。这个结构体通常包含两部分：数据成员和指向下一个节点的指针成员。

2）节点的创建与初始化：
可以通过动态内存分配（malloc 函数）来创建新的节点，并通过赋值操作对节点中的数据和指针进行初始化。

3）插入与删除节点：
可以编写函数来实现在链表中插入新节点或删除现有节点的操作。这些操作通常涉及对节点之间的指针进行调整。

4）遍历与访问：
为了能够访问链表中的所有节点，需要使用循环结构或递归来依次访问每个节点，并进行相应的操作。

5）释放内存：
在链表不再需要时，需要确保释放所有节点所占用的内存，以避免内存泄漏。

具体代码实现如下：

#include <stdio.h>
#include <stdlib.h>// 定义链表节点的结构体
struct Node {int data;struct Node* next;
};// 在链表末尾插入新节点
void appendNode(struct Node** headRef, int newData) {struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));struct Node* last = *headRef;newNode->data = newData;newNode->next = NULL;if (*headRef == NULL) {*headRef = newNode;return;}while (last->next != NULL) {last = last->next;}last->next = newNode;
}// 打印链表中的所有节点数据
void printList(struct Node* node) {while (node != NULL) {printf("%d -> ", node->data);node = node->next;}printf("NULL\n");
}int main() {// 初始化头节点struct Node* head = NULL;// 在链表末尾依次插入节点appendNode(&head, 1);appendNode(&head, 2);appendNode(&head, 3);// 打印链表printf("Linked list: ");printList(head);return 0;
}

第一题）递归删除不带头节点链表中指定值

设计一个递归算法，删除不带头节点的单链表L中所有值为 x 的结点。

实现思路如下：

首先：代码定义了一个单链表的数据结构，每个节点包含一个整型数据和一个指向下一个节点的指针。
然后：在deleteNodes函数中，首先检查链表是否为空。如果为空，则返回空。否则，递归调用deleteNodes函数，对链表的下一个节点进行删除操作。
接着：在deleteNodes函数中，如果当前节点的数据等于要删除的元素x，那么就删除当前节点。具体操作是，先保存下一个节点的指针，然后释放当前节点的内存，最后返回下一个节点的指针。
最后：在main函数中，首先获取用户输入的单链表长度和元素，然后调用deleteNodes函数删除指定元素，最后打印删除后的单链表结果。

#include <stdio.h>  
#include <stdlib.h>  struct Node {int data;struct Node* next;
};struct Node* createNode(int data) {struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));if (newNode == NULL) {printf("链表为空，请重新创建：\n");exit(1);}newNode->data = data;newNode->next = NULL;return newNode;
}void insertNode(struct Node** head, int data) {struct Node* newNode = createNode(data);if (*head == NULL) {*head = newNode;return;}struct Node* curr = *head;while (curr->next != NULL) {curr = curr->next;}curr->next = newNode;
}struct Node* deleteNodes(struct Node* head, int x) {struct Node* prev = NULL;struct Node* curr = head;while (curr != NULL) {if (curr->data == x) {if (prev == NULL) {head = curr->next;}else {prev->next = curr->next;}free(curr);return head;}prev = curr;curr = curr->next;}return head;
}void printList(struct Node* head) {while (head != NULL) {printf("%d ", head->data);head = head->next;}printf("\n");
}int main() {struct Node* head = NULL;int n, data, x;printf("请输入单链表的长度: ");if (scanf_s("%d", &n) != 1 || n < 0) {printf("输入长度有误！请重新输入：\n");return 1;}printf("请输入单链表的元素: ");for (int i = 0; i < n; i++) {if (scanf_s("%d", &data) != 1 || data < 0) {printf("输入元素有误！请重新输入.\n");return 1;}insertNode(&head, data);}printf("请输入要删除的元素: ");if (scanf_s("%d", &x) != 1 || x < 0) {printf("删除元素有误！请重新删除.\n");return 1;}head = deleteNodes(head, x);printf("最终的单链表结果为: ");printList(head);return 0;
}

执行代码结果展示如下：

第二题）带头节点链表删除指定值

在带头节点的单链表 L 中，删除所有值为 x 的结点，并释放其空间，假设值为 x 的结点不唯一，试编写算法以实现上述操作。

实现思路如下：

首先：我们定义了单链表的结点结构体，并创建了一个带头节点的单链表。

接着：我们实现了向单链表中插入新结点和删除单链表中所有值为 x 的结点的功能。

然后：在主函数中，我们首先输入单链表的结点个数和值，并将这些值插入到单链表中，输入要删除的结点值，并调用删除结点的函数。

最后：我们打印出删除后的单链表。这样就完成了整体代码的四个步骤。

#include <stdio.h>
#include <stdlib.h>// 定义单链表结点结构体
typedef struct Node {int data;struct Node* next;
} Node;// 创建带头节点的单链表
Node* createLinkedList() {Node* head = (Node*)malloc(sizeof(Node));head->next = NULL;return head;
}// 向单链表中插入新结点
void insertNode(Node* head, int value) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = value;newNode->next = NULL;Node* p = head;while (p->next != NULL) {p = p->next;}p->next = newNode;
}// 删除单链表中所有值为 x 的结点
void deleteNodes(Node* head, int x) {Node* p = head->next;Node* prev = head;while (p != NULL) {if (p->data == x) {Node* temp = p;prev->next = p->next;p = p->next;free(temp);}else {prev = p;p = p->next;}}
}// 打印单链表
void printLinkedList(Node* head) {Node* p = head->next;while (p != NULL) {printf_s("%d ", p->data);p = p->next;}printf_s("\n");
}int main() {Node* list = createLinkedList();// 输入单链表数据int n;printf_s("请输入单链表的结点个数：");scanf_s("%d", &n);printf_s("请输入单链表的结点值：\n");for (int i = 0; i < n; i++) {int value;scanf_s("%d", &value);insertNode(list, value);}// 输入要删除的结点值int x;printf_s("请输入要删除的结点值：");scanf_s("%d", &x);// 删除值为 x 的结点deleteNodes(list, x);// 打印删除后的单链表printf_s("删除后的单链表：");printLinkedList(list);return 0;
}

执行代码结果展示如下：

第三题）反向输出链表值

设L为带头节点的单链表，编写算法实现从尾到头反向输出每个结点的值。

实现思路如下：

首先：程序定义了一个Link结构体，用于表示链表的节点，每个节点包含一个整数数据和一个指向下一个节点的指针。

接着：在函数reverseOutput中，首先判断传入的链表节点指针是否为空，如果为空，则直接返回。否则，递归地调用reverseOutput函数，并传入该节点的下一个节点指针。这样可以先逆序输出链表后面的节点。

然后：在递归调用之后，打印当前节点的数据，用printf_s函数输出。

最后：在main函数中，首先读取用户输入的创建链表的节点个数。然后定义两个指针变量q和head，其中q用于指向链表的头指针，head用于指向最新的节点。接下来，通过循环创建链表的节点，每次循环创建一个新的节点，让head->next指向新节点，然后将head指向新节点，以保证head始终指向最新的节点。最后，将链表的最后一个节点的next指针置为NULL，将head重新指向q，即将head指向链表头节点。最后，调用reverseOutput函数输出逆序的链表元素。最后，返回0表示程序正常结束。

#include <stdio.h>
#include <stdlib.h>struct Link {int data;struct Link* next;
};void reverseOutput(Link* p) {if (p == NULL) return;else {reverseOutput(p->next);printf_s("%d ", p->data);}
}int main() {int n, data;printf_s("请输入创建链表的结点个数：");scanf_s("%d", &n);struct Link* q;struct Link* head = (struct Link*)malloc(sizeof(struct Link));head->next = NULL;q = head;for (int i = 0; i < n; i++){struct Link* newP = (struct Link*)malloc(sizeof(struct Link));printf_s("请输入第 %d 个结点的值：",i+1);scanf_s("%d", &data);newP->data = data;newP->next = NULL;head->next = newP;head = head->next; // head要始终指向最新节点}head->next = NULL;head = q; // 最后head要指向头结点reverseOutput(head->next);return 0;
}

执行代码结果展示如下： 

第四题） 带头节点的单链表删除最小值结点

试编写在带头结点的单链表L中删除一个最小值结点的高效算法(假设最小值结点是唯一的)

实现思路如下：

首先：代码定义了一个链表结点结构体 Node，其中包含数据域 data 和指向下一个结点的指针next。

接着：通过createLinkedList函数创建了一个带头结点的单链表。在函数内部，我们使用malloc函数为头结点分配内存，并将头结点的next指针指向NULL，表示链表为空。

然后：使用insertNode函数向链表中插入新节点。该函数接受一个链表头结点指针head和要插入的值value作为参数。在函数内部，我们首先创建一个新的结点newNode，并为其分配内存。然后，我们遍历链表，找到链表的尾部结点，将新节点插入到尾部结点的next指针处。

最后：通过deleteMinNode函数删除链表中的最小值结点。该函数接受链表头结点指针head作为参数。在函数内部，我们使用两个指针prev和curr来遍历链表，找到最小值结点以及其前一个结点。然后，我们将最小值结点的前一个结点的`next`指针指向最小值结点的下一个结点，并释放最小值结点的内存。

#include <stdio.h>
#include <stdlib.h>// 定义链表结点结构体
typedef struct Node {int data;struct Node* next;
} Node;// 创建带头结点的单链表
Node* createLinkedList() {Node* head = (Node*)malloc(sizeof(Node));head->next = NULL;return head;
}// 向链表中插入新节点
void insertNode(Node* head, int value) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = value;newNode->next = NULL;Node* curr = head;while (curr->next != NULL) {curr = curr->next;}curr->next = newNode;
}// 删除最小值结点
void deleteMinNode(Node* head) {if (head == NULL || head->next == NULL) {return;}Node* prev = head;Node* curr = head->next;Node* minPrev = prev; // 最小值结点的前一个结点Node* minNode = curr; // 最小值结点while (curr != NULL) {if (curr->data < minNode->data) {minPrev = prev;minNode = curr;}prev = curr;curr = curr->next;}minPrev->next = minNode->next;free(minNode);
}// 打印链表
void printLinkedList(Node* head) {if (head == NULL || head->next == NULL) {printf("链表为空\n");return;}Node* curr = head->next;while (curr != NULL) {printf("%d ", curr->data);curr = curr->next;}printf("\n");
}int main() {Node* L = createLinkedList();int n;  // 链表长度printf("请输入链表的长度：");scanf_s("%d", &n);printf("请输入链表的元素：\n");for (int i = 0; i < n; i++) {int value;scanf_s("%d", &value);insertNode(L, value);}printf("原始链表：");printLinkedList(L);deleteMinNode(L);printf("删除最小值结点后的链表：");printLinkedList(L);return 0;
}

执行代码结果展示如下：  

第五题）求两链表交集

已知两个链表A和B分别表示两个集合，其元素递增排序。编制函数，求A与B的交集，并存放于A链表中。

实现思路如下：

首先：通过createLinkedList函数创建了两个带头结点的单链表A和B。该函数分配了内存空间，并将头结点的next指针指向NULL，表示链表为空。

接着：使用scanf_s函数获取用户输入的整数n和m，分别表示链表A和B的长度。

然后：调用findIntersection函数，传入A链表和B链表作为参数。该函数用于找到A链表和B链表的交集，并将结果存放在A链表中。

最后：通过printLinkedList函数分别打印出原始的A和B链表以及交集结果。

#include <stdio.h>
#include <stdlib.h>typedef struct Node {int data;struct Node* next;
} Node;// 创建带头结点的单链表
Node* createLinkedList() {Node* head = (Node*)malloc(sizeof(Node));head->next = NULL;return head;
}// 向链表中插入新节点
void insertNode(Node* head, int value) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = value;newNode->next = NULL;Node* curr = head;while (curr->next != NULL) {curr = curr->next;}curr->next = newNode;
}// 求两个递增排序链表的交集，并将结果存放于A链表中
void findIntersection(Node* A, Node* B) {Node* currA = A->next;Node* currB = B->next;Node* prevA = A;Node* temp;while (currA != NULL && currB != NULL) {if (currA->data < currB->data) {prevA->next = currA->next;temp = currA;currA = currA->next;free(temp);}else if (currA->data > currB->data) {currB = currB->next;}else {prevA = currA;currA = currA->next;currB = currB->next;}}while (currA != NULL) {prevA->next = currA->next;temp = currA;currA = currA->next;free(temp);}
}// 打印链表
void printLinkedList(Node* head) {if (head == NULL || head->next == NULL) {printf("链表为空\n");return;}Node* curr = head->next;while (curr != NULL) {printf("%d ", curr->data);curr = curr->next;}printf("\n");
}int main() {Node* A = createLinkedList();Node* B = createLinkedList();int n, m; // A链表长度和B链表长度printf("请输入A链表的长度：");scanf_s("%d", &n);printf("请输入A链表的元素（递增排序）：\n");for (int i = 0; i < n; i++) {int value;scanf_s("%d", &value);insertNode(A, value);}printf("请输入B链表的长度：");scanf_s("%d", &m);printf("请输入B链表的元素（递增排序）：\n");for (int i = 0; i < m; i++) {int value;scanf_s("%d", &value);insertNode(B, value);}printf("原始A链表：");printLinkedList(A);printf("原始B链表：");printLinkedList(B);findIntersection(A, B);printf("A与B的交集结果：");printLinkedList(A);return 0;
}

执行代码结果展示如下： 

第六题）单链表排序

有一个带头结点的单链表L，设计一个算法使其元素递增有序。

实现思路如下：

首先：定义了链表节点结构体ListNode，包含数据域和指向下一个节点的指针。

接着：实现了创建新节点的函数createNewNode，用于分配内存并初始化新节点。

然后：实现了将元素插入有序链表的函数insertInOrder，根据元素大小找到合适的位置插入新节点，并保持链表的有序性。

最后：在主函数中，通过用户输入创建带头结点的链表L，并调用insertInOrder将输入的元素按递增顺序插入链表中，最后打印排列后的链表内容。

#include <stdio.h>
#include <stdlib.h>// 定义链表节点结构体
typedef struct ListNode {int data;struct ListNode* next;
} ListNode;// 创建新节点
ListNode* createNewNode(int data) {ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));newNode->data = data;newNode->next = NULL;return newNode;
}// 将元素插入有序链表中
void insertInOrder(ListNode** head, int data) {ListNode* newNode = createNewNode(data);// 如果链表为空或者新节点的值小于头结点的值，则将新节点作为头结点if (*head == NULL || data < (*head)->data) {newNode->next = *head;*head = newNode;}else {ListNode* curr = *head;// 找到适当的位置插入新节点while (curr->next != NULL && data > curr->next->data) {curr = curr->next;}newNode->next = curr->next;curr->next = newNode;}
}// 打印链表的内容
void printLinkedList(ListNode* head) {ListNode* curr = head;while (curr != NULL) {printf("%d ", curr->data);curr = curr->next;}printf("\n");
}// 从键盘读取用户输入的整数
int readInt() {int num;scanf_s("%d", &num);return num;
}// 主函数
int main() {// 创建带头结点的链表LListNode* L = createNewNode(0);printf("请输入链表L的元素个数：");int n = readInt();for (int i = 0; i < n; i++) {printf("请输入第%d个元素：", i + 1);int data = readInt();insertInOrder(&L, data);}printf("排列后的链表L: ");printLinkedList(L->next);return 0;
}

执行代码结果展示如下： 

第七题）删除重复结点

设计一个算法完成以下功能：在单链表中删除重复结点。

实现思路如下：

首先：定义了链表节点的结构体。

接着：实现了创建新节点的函数和打印链表的函数。

然后：实现了删除重复节点的函数。该函数通过遍历链表，对于每一个节点，再次遍历链表来找到并删除与当前节点数据相同的节点。

最后：实现了主函数。在主函数中，首先要求用户输入链表的元素个数和具体数值，然后根据输入创建一个单链表。接着调用删除重复节点的函数，再打印出删除重复节点后的链表。最后，释放链表内存。

#include <stdio.h>
#include <stdlib.h>// 定义链表节点结构体
typedef struct ListNode {int data;struct ListNode* next;
} ListNode;// 创建新节点
ListNode* createNewNode(int data) {ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));newNode->data = data;newNode->next = NULL;return newNode;
}// 打印链表
void printList(ListNode* head) {ListNode* current = head;while (current != NULL) {printf("%d ", current->data);current = current->next;}printf("\n");
}// 删除重复节点
void removeDuplicates(ListNode* head) {if (head == NULL) {return;}ListNode* current = head;while (current != NULL) {ListNode* runner = current;while (runner->next != NULL) {if (runner->next->data == current->data) {ListNode* duplicate = runner->next;runner->next = runner->next->next;free(duplicate);}else {runner = runner->next;}}current = current->next;}
}// 释放链表内存
void freeList(ListNode* head) {ListNode* current = head;while (current != NULL) {ListNode* temp = current;current = current->next;free(temp);}
}// 主函数
int main() {int n;printf("请输入链表元素个数：");scanf_s("%d", &n);ListNode* head = NULL;ListNode* tail = NULL;printf("请输入链表元素值：");for (int i = 0; i < n; i++) {int data;scanf_s("%d", &data);ListNode* newNode = createNewNode(data);if (head == NULL) {head = newNode;tail = newNode;}else {tail->next = newNode;tail = newNode;}}printf("原链表：");printList(head);removeDuplicates(head);printf("删除重复节点后的链表：");printList(head);// 释放链表内存freeList(head);return 0;
}

执行代码结果展示如下： 

第八题）删除绝对值相等的结点

设计一个算法完成以下功能：在单链表中删除绝对值相等的元素。

实现思路如下：

首先：定义了一个链表节点的结构体，并实现了创建新节点、打印链表、删除绝对值相等节点和释放链表内存的函数。

接着：主函数中要求用户输入链表元素的个数和具体数值，然后根据输入创建一个单链表。

然后：调用removeAbsoluteDuplicates函数来删除链表中绝对值相等的节点。

最后：打印出删除绝对值相等节点后的链表，并释放链表的内存。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>// 定义链表节点结构体
typedef struct ListNode {int data;struct ListNode* next;
} ListNode;// 创建新节点
ListNode* createNewNode(int data) {ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));newNode->data = data;newNode->next = NULL;return newNode;
}// 打印链表
void printList(ListNode* head) {ListNode* current = head;while (current != NULL) {printf("%d ", current->data);current = current->next;}printf("\n");
}// 删除绝对值相等节点
void removeAbsoluteDuplicates(ListNode* head) {if (head == NULL) {return;}ListNode* current = head;while (current != NULL && current->next != NULL) {ListNode* runner = current;while (runner->next != NULL) {if (abs(runner->next->data) == abs(current->data)) {ListNode* duplicate = runner->next;runner->next = runner->next->next;free(duplicate);}else {runner = runner->next;}}current = current->next;}
}// 释放链表内存
void freeList(ListNode* head) {ListNode* current = head;while (current != NULL) {ListNode* temp = current;current = current->next;free(temp);}
}// 主函数
int main() {int n;printf("请输入链表元素个数：");scanf_s("%d", &n);ListNode* head = NULL;ListNode* tail = NULL;printf("请输入链表元素值：");for (int i = 0; i < n; i++) {int data;scanf_s("%d", &data);ListNode* newNode = createNewNode(data);if (head == NULL) {head = newNode;tail = newNode;}else {tail->next = newNode;tail = newNode;}}printf("原链表：");printList(head);removeAbsoluteDuplicates(head);printf("删除绝对值相等节点后的链表：");printList(head);// 释放链表内存freeList(head);return 0;
}

执行代码结果展示如下： 

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

硬件基础：光耦、可控硅、继电器、达林顿管、干簧管

硬件基础：光耦、可控硅、继电器、达林顿管、干簧管

光耦 光电耦合器&#xff08;optical coupler&#xff0c;英文缩写为OC&#xff09;亦称光电隔离器&#xff0c;简称光耦。 光电耦合器是一种把发光器件和光敏器件封装在同一壳体内&#xff0c; 中间通过电→光→电的转换来传输电信号的半导体光电子器件。其中&#xff0c;发光…
阅读更多...
re:Invent2023大会隆重推出自研芯片Graviton4和Trainium2

re:Invent2023大会隆重推出自研芯片Graviton4和Trainium2

目录 一、前言 二、体验Graviton系列产品 &#xff08;一&#xff09;创建普通的EC2实例 &#xff08;二&#xff09;创建Graviton处理器的EC2实例 &#xff08;三&#xff09;远程到服务器 方式1&#xff1a;创建成功时连接 方式2&#xff1a;SSH客户端 方式3&#xff1a;正确…
阅读更多...
基于FPGA的视频接口之高速IO(SATA)

基于FPGA的视频接口之高速IO(SATA)

简介 本章节是对于高速IO接口应用的一个扩展，目前扩展为SATA（SSD硬盘，机械硬盘不能使用）。通俗易懂的讲，即把SSD硬盘当做大型的Nand Flash来处理，不格式化硬盘，直接以地址和数据的格式，在SATA盘中写入数据，该数据不能被Window和linux直接识别，需单独编写App来查看SSD…
阅读更多...
创建型模式之工厂模式

创建型模式之工厂模式

​ 本质&#xff1a; 实例化对象不直接使用new&#xff0c;而是用工厂代替 工厂模式分为&#xff1a; 简单工厂模式&#xff1a;用来生产同一等级结构中的任意产品&#xff08;增加新产品需要修改已有代码&#xff09;工厂方法模式&#xff1a;用来生产同一等级结构中的固定产…
阅读更多...
关于找不到XINPUT1_3.dll,无法继续执行代码问题的5种不同解决方法

关于找不到XINPUT1_3.dll,无法继续执行代码问题的5种不同解决方法

一、xinput1_3.dll的作用 xinput1_3.dll是Windows操作系统中的一款动态链接库文件&#xff0c;主要用于支持游戏手柄和游戏输入设备。这款文件属于Microsoft Xbox 360兼容性库&#xff0c;它包含了与游戏手柄和其他输入设备相关的功能。在游戏中&#xff0c;xinput1_3.dll负责…
阅读更多...
C语言——预处理详解(#define用法+注意事项）

C语言——预处理详解(#define用法+注意事项）

#define 语法规定 #define定义标识符 语法: #define name stuff #define例子 #include<stdio.h> #define A 100 #define STR "abc" #define FOR for(;;)int main() {printf("%d\n", A);printf("%s\n", STR);FOR;return 0; } 运行结果…
阅读更多...
JRT实现在线打印预览

JRT实现在线打印预览

在JRT打印元素绘制协议一篇已经介绍过打印把绘图和打印逻辑进行了分离&#xff0c;这是和老设计最大的不同。因为老的设计时候没想着做在线预览功能&#xff0c;是后面硬性扩出来的。这次从最初设计就考虑绘图逻辑各处共用&#xff0c;包括打印预览&#xff0c;在线打印预览等、…
阅读更多...
JS代码输出题：return Promise.resolve() 情况

JS代码输出题：return Promise.resolve() 情况

题目&#xff1a; Promise.resolve().then(() > {console.log(0);return Promise.resolve(4);}).then((res) > {console.log(res)})Promise.resolve().then(() > {console.log(1)}).then(() > {console.log(2)}).then(() > {console.log(3)}).then(() > {con…
阅读更多...
MDK编译过程和文件类型

MDK编译过程和文件类型

MDK是一款IDE软件&#xff0c;具有&#xff0c;编辑&#xff0c;编译&#xff0c;链接&#xff0c;下载&#xff0c;调试等等的功能。 1.编译器介绍&#xff1a; MDK可以编译C/C文件和汇编文件&#xff0c;MDK只是一款IDE软件&#xff0c;那他内部使用的是什么编译器呢&#x…
阅读更多...
Python-折线图可视化

Python-折线图可视化

折线图可视化 1.JSON数据格式2.pyecharts模块介绍3.pyecharts快速入门4.创建折线图 1.JSON数据格式 1.1什么是JSON JSON是一种轻量级的数据交互格式。可以按照JSON指定的格式去组织和封装数据JSON本质上是一个带有特定格式的字符串 1.2主要功能json就是一种在各个编程语言中流…
阅读更多...
JavaSE第7篇：封装

JavaSE第7篇：封装

文章目录 一、封装1、好处:2、使用 二、四种权限修饰符三、构造器1、作用2、说明3、属性赋值的过程 一、封装 封装就是将类的属性私有化,提供公有的方法访问私有属性 不对外暴露打的私有的方法 单例模式 1、好处: 1.只能通过规定的方法来访问数据 2.隐藏类的实例细节,方便…
阅读更多...
CSS篇之圆角梯形

CSS篇之圆角梯形

附上一篇文章&#xff1a;梯形tab按钮-基于clip-path path函数实现 - JSRUN.NET 他这个区别在于&#xff0c;收尾两侧都是直角的&#xff0c;如图 下面这个是圆角&#xff1a; 思路&#xff1a; 代码如下&#xff1a; <template><div class"wrap"><…
阅读更多...
时序数据库选型TimescaleDB

时序数据库选型TimescaleDB

最近要做一个数字车间的物联网项目&#xff0c;数据存储成了首先要解决的问题&#xff0c;整个车间一共104台数控机床&#xff0c;1s钟采集1次数据&#xff0c;360024365*1043,279,744,000 &#xff0c;一年要产生32亿条记录&#xff0c;这个数据量用常见的关系型数据库肯定是不…
阅读更多...
【C语言加油站】qsort函数的模拟实现

【C语言加油站】qsort函数的模拟实现

qsort函数的模拟实现 导言一、回调函数二、冒泡排序2.1 冒泡排序实现升序 三、qsort函数3.1 qsort函数的使用3.2 比较函数 四、通过冒泡排序模拟实现qsort函数4.1 任务需求4.2 函数参数4.3 函数定义与声明4.4 函数实现4.4.1 函数主体4.4.2 比较函数4.4.3 元素交换 4.5 my_qsort…
阅读更多...
Mrdoc知识文档

Mrdoc知识文档

MrDoc知识文档平台是一款基于Python开发的在线文档系统&#xff0c;适合作为个人和中小型团队的私有云文档、云笔记和知识管理工具&#xff0c;致力于成为优秀的私有化在线文档部署方案。我现在主要把markdown笔记放在上面&#xff0c;因为平时老是需要查询一些知识点&#xff…
阅读更多...
mysql使用st_distance_sphere函数报错Incorrect arguments to st_distance_sphere

mysql使用st_distance_sphere函数报错Incorrect arguments to st_distance_sphere

前言 最近使用空间点位查询数据时函数报错Incorrect arguments to st_distance_sphere报错。 发现问题 因为之前是没有问题的&#xff0c;所以把问题指向了数据&#xff0c;因为是外部数据&#xff0c;不是通过系统打点获取&#xff0c;发现是因为经纬度反了&#xff0c;loc…
阅读更多...
软件测试指南

软件测试指南

软件测试指南 软件集成测试软件系统测试&#xff08;功能性测试&#xff0c;性能测试&#xff09;
阅读更多...
事件监听的艺术：掌握`addEventListener`的魅力

事件监听的艺术：掌握`addEventListener`的魅力

&#x1f90d; 前端开发工程师&#xff08;主业&#xff09;、技术博主&#xff08;副业&#xff09;、已过CET6 &#x1f368; 阿珊和她的猫_CSDN个人主页 &#x1f560; 牛客高级专题作者、在牛客打造高质量专栏《前端面试必备》 &#x1f35a; 蓝桥云课签约作者、已在蓝桥云…
阅读更多...
【Vulnhub 靶场】【IA: Keyring (1.0.1)】【中等】【20210730】

【Vulnhub 靶场】【IA: Keyring (1.0.1)】【中等】【20210730】

1、环境介绍 靶场介绍&#xff1a;https://www.vulnhub.com/entry/ia-keyring-101,718/ 靶场下载&#xff1a;https://download.vulnhub.com/ia/keyring-v1.01.ova 靶场难度&#xff1a;中等 发布日期&#xff1a;2021年07月30日 文件大小&#xff1a;1.1 GB 靶场作者&#xf…
阅读更多...
基于Mamdani模糊神经网络的调速控制系统simulink建模与仿真

基于Mamdani模糊神经网络的调速控制系统simulink建模与仿真

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 4.1 模糊神经网络控制器概述 4.2 模糊神经网络控制器基本原理 5.算法完整程序工程 1.算法运行效果图预览 2.算法运行软件版本 matlab2022a 3.部分核心程序 ............................…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023