数据结构之细说链表

1.1顺序表的问题以及思考

经过上一篇顺序表的学习，我们知道顺序表还是有很多缺点

顺序表的缺点：

1.中间/头部的插入删除，实际复杂度为O(N)

2.增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗

3.扩容一般是呈两倍增长，势必会有一定的空间浪费。

例如当前空间的容量是100，满了之后扩容到200，我们在继续插入了5个数据，后面就没有继续插入了，这样就会浪费95个空间。

如何解决这些问题了？下面我们给出链表的构成，看看链表是如何解决这些问题的

1.2链表的概念以及结构

概念：链表是一种物理储存结构上非连续，非顺序的存储结构，数据元素的逻辑结构是通过链表中的指针连接次序实现的。像一个小火车一样一节连接这一节

链式结构在逻辑上是连续的，但是在物理结构上不一定连续，它们的空间都是在堆上动态申请的，两次申请空间可能连续，则也可能不连续

1.3链表的分类

实际中的链表结构非常多样，以下情况结合起来就有8种链表结构：

1.单向或者双向

2.带头或者不带头

3.循环或者非循环

看着有这么多链表组合起来其实更多

将它们组合起来一共有8种结构

虽然有这么多链表的结构，但是我们实际中最常用的还是两种结构：

我们只要将这两种结构熟练掌握了其他的结构就差不多了

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

2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

1.4单向链表（于顺序表一样：实现增删查改）

需要实现的功能和要用到的头文件

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>typedef struct SListNode
{SLTDataType data;struct SListNode * next;
}SLTNode;typedef int SLTDataType;//打印数据
void SLTPrint(SLTNode* phead);//查找数据
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);//增加节点
SLTNode* BuySLTNode(SLTDataType x);//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);//尾删
void SLTPopBack(SLTNode** pphead);//头删
void SLTPopFront(SLTNode** pphead);//任意位置插入节点
void SLTinsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);//任意位置删除节点 
void SLTerase(SLTNode** phead, SLTDataType x);//pos位置之后删除
void SLTPoppushAfter(SLTNode* pos);//pos位置之后插入
void SLTPopFrontAfter(SLTNode* pos, SLTDataType x);//删除链表
void SLTDestroy(SLTNode** pphead);

->1.打印数据

//打印数据
void SLTPrint(SLTNode* phead)
{SLTNode* newnode = phead;while (newnode != NULL){printf("%d -> ", newnode->data);newnode = newnode->next;}printf("NULL");printf("\n");
}

打印数据是不需要用assert来检查的，因为就算没有数据也可以打印，顺序表也是这样，如果phead传进来的是一个空指针被assert断言就会强制终止程序，就不会打印了，因为打印数据只需要使用结构体就行了，不需要改变结构体指针

->2.查找数据

//查找数据
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{assert(phead);SLTNode* cur = phead;while (cur->next != NULL){cur = cur->next;if (cur->data == x){return cur;}}return NULL;
}

查找数据需要一个有效的地址，如果你传进来的空指针，那你找它有什么意义了cur->next还会对空指针越界访问，所以这里需要assert断言一下

 ->3.增加节点

//增加节点
SLTNode* BuySLTNode(SLTDataType x)
{SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));if (NULL == newnode){perror("BuySLTNode::malloc");return NULL;}newnode->data = x;newnode->next = NULL;return newnode;
}

在堆上申请空间，创建一个新节点，然后返回指针

->4.尾插

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuySLTNode(x);if (NULL == *pphead){*pphead = newnode;}else{//找尾SLTNode* tail = *pphead;while (tail->next != NULL){tail = tail->next;}tail->next = newnode;}
}

因为这里形参为一级指针的地址是绝对不可能为空指针的所以这里需要断言一下pphead是否为空先判断该链表是否有节点，如果没有就将需要尾插的节点直接给pphead，就行了。如果该链表本来就有地址那就先找尾，然后把节点连接到最后一共节点后面

->5.尾删

//尾删
void SLTPopBack(SLTNode** pphead)
{assert(pphead);assert(*pphead);SLTNode* tail = *pphead;while (tail->next->next != NULL){tail = tail->next;}free(tail->next);tail->next = NULL;
}

尾删，如果链表没有节点的话肯定是删不了的，所以*pphead需要断言一下，然后phead也断言一下。这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了

->6.头插

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuySLTNode(x);newnode->next = *pphead;*pphead = newnode;
}

头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。也可以用一个指针变量先存放第二个节点的位置。这里pphead也需要断言

->7.头删

//头删
void SLTPopFront(SLTNode** pphead)
{assert(pphead);  //暴力检查assert(*pphead);SLTNode* first = *pphead;*pphead = first->next;free(first);first = NULL;
}

头删需要断言pphead还有*pphead删节点，链表不能为空吧，为空你还需要删除就没有意义了

->8.查找数据

//查找数据
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{assert(phead);SLTNode* cur = phead;while (cur->next != NULL){if (cur->data == x){return cur;}cur = cur->next;}return NULL;
}

断言phead，这个if条件判断语句应该放到cur->next的上面，因为可能第一个节点就是我们需要找到的x

->9.pos位置之前插入节点

//任意插入节点
void SLTinsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{assert(pos);assert(pphead);if (*pphead == pos){SLTPushFront(&pos, x);}SLTNode* cur = *pphead;while (cur->next != pos){cur = cur->next;}SLTNode* newnode = BuySLTNode(x);newnode->next = cur->next;cur->next = newnode;
}

断言phead和pos，断言pos是因为如果pos为空的话，那该在那个位置插入都不清楚了

->10.pos位置之前删除节点

//任意位置删除节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{assert(*pphead);assert(pos);assert(pphead);if (*pphead == pos){SLTPopFront(&pos);}else{SLTNode* cur = *pphead;while (cur->next != pos){cur = cur->next;}cur->next = pos->next;free(pos);}
}

两个个要注意的地方：1.当*pphead 等于 pos时直接头删就可以了 2.需要断言*pphead，因为*pphead为空，没有可删除的节点

->11.pos位置之后插入节点

//pos位置之后插入
void SLTPopFrontAfter(SLTNode* pos, SLTDataType x)
{assert(pos);SLTNode* newnode = BuySLTNode(x);newnode->next = pos->next->next;pos->next = newnode;
}

->12.pos位置之后删除节点

//pos位置之后删除
void SLTPoppushAfter(SLTNode* pos)
{assert(pos);SLTNode* del = pos->next;pos->next = del->next;free(del);del = NULL;
}

->13.清空所有节点

//删除所有节点
void SLTDestroy(SLTNode** pphead)
{assert(pphead);assert(*pphead);SLTNode* cur = *pphead;while (cur){SLTNode* del = cur->next;free(cur);cur = del;}*pphead = NULL;
}

1.5单向链表的实现

SList.h

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>typedef int SLTDataType;
typedef struct SListNode
{SLTDataType data;struct SListNode * next;
}SLTNode;//打印数据
void SLTPrint(SLTNode* phead);//查找数据
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);//增加链表
SLTNode* BuySLTNode(SLTDataType x);//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);//尾删
void SLTPopBack(SLTNode** pphead);//头删
void SLTPopFront(SLTNode** pphead);//插入
void SLTinsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);//删除数据 
void SLTerase(SLTNode** phead, SLTDataType x);//pos位置之后删除
void SLTPoppushAfter(SLTNode* pos);//pos位置之后插入
void SLTPopFrontAfter(SLTNode* pos, SLTDataType x);//清空所有节点
void SLTDestroy(SLTNode** pphead);

SList.c

#include "SList.h"//打印链表
void SLTPrint(SLTNode* phead)
{SLTNode* newnode = phead;while (newnode != NULL){printf("%d -> ", newnode->data);newnode = newnode->next;}printf("NULL");printf("\n");
}//增加链表
SLTNode* BuySLTNode(SLTDataType x)
{SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));if (NULL == newnode){perror("BuySLTNode::malloc");return NULL;}newnode->data = x;newnode->next = NULL;return newnode;
}//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{assert(pphead);//找尾SLTNode* newnode = BuySLTNode(x);if (NULL == *pphead){*pphead = newnode;}else{SLTNode* tail = *pphead;while (tail->next != NULL){tail = tail->next;}tail->next = newnode;}//SLTinsert(pphead, newnode, x);
}//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuySLTNode(x);newnode->next = *pphead;*pphead = newnode;
}//尾删
void SLTPopBack(SLTNode** pphead)
{assert(pphead);assert(*pphead);SLTNode* tail = *pphead;while (tail->next->next != NULL){tail = tail->next;}free(tail->next);tail->next = NULL;
}//头删
void SLTPopFront(SLTNode** pphead)
{assert(pphead);  //暴力检查assert(*pphead);SLTNode* first = *pphead;*pphead = first->next;free(first);first = NULL;
}//查找节点
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{assert(phead);SLTNode* cur = phead;while (cur->next != NULL){cur = cur->next;if (cur->data == x){return cur;}}return NULL;
}//pos位置之前插入节点
void SLTinsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{assert(pos);assert(pphead);if (*pphead == pos){SLTPushFront(&pos, x);}SLTNode* cur = *pphead;while (cur->next != pos){cur = cur->next;}SLTNode* newnode = BuySLTNode(x);newnode->next = cur->next;cur->next = newnode;
}//pos位置之前删除节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{assert(*pphead);assert(pos);assert(pphead);if (*pphead == pos){SLTPopFront(&pos);}else{SLTNode* cur = *pphead;while (cur->next != pos){cur = cur->next;}cur->next = pos->next;free(pos);}
}//pos位置之后删除
void SLTPoppushAfter(SLTNode* pos)
{assert(pos);SLTNode* del = pos->next;pos->next = del->next;free(del);del = NULL;
}//pos位置之后插入
void SLTPopFrontAfter(SLTNode* pos, SLTDataType x)
{assert(pos);SLTNode* newnode = BuySLTNode(x);newnode->next = pos->next->next;pos->next = newnode;
}//清空所有节点
void SLTDestroy(SLTNode** pphead)
{assert(pphead);assert(*pphead);SLTNode* cur = *pphead;while (cur){SLTNode* del = cur->next;free(cur);cur = del;}*pphead = NULL;
}

test.c

#include "SList.h"int main()
{SLTNode* plist = NULL;SLTPushBack(&plist, 1);SLTPushBack(&plist, 2);SLTPushBack(&plist, 3);SLTPushBack(&plist, 4);SLTPrint(plist);SLTNode* pos = SLTFind(plist, 3);SLTinsert(&plist, pos, 8);SLTPrint(plist);pos = SLTFind(plist, 4);SLTErase(&plist, pos);pos = NULL;SLTPrint(plist);SLTDestroy(&plist);SLTPrint(plist);/*free(plist);plist = NULL;*/return 0;
}

测试结果：

1.6带头双向循环链表

需要实现的功能和要用到的头文件

因为是带头双向循环链表所有得有两个接点一个prev，一个next

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>typedef int LTDataType;typedef struct ListNode
{struct ListNode* prev;LTDataType data;struct ListNode* next;
}LTNode;//链表初始化
LTNode* LTInIt();
//清空所有节点
void LTDestroy(LTNode* phead);
//判断链表中是否有其他节点(除了带哨兵位的头节点)
bool LTEmpty(LTNode* phead);
//增加一个节点
LTNode* BuyListNode(LTDataType x);
//打印链表
void Print(LTNode* phead);//尾插
void LTPushBack(LTNode* phead, LTDataType x);
//尾删
void LTPopBack(LTNode* phead);
//头插
void LTPushFront(LTNode* phead, LTDataType x);
//头删
void LTPopFront(LTNode* phead);//查找节点地址
LTNode* LTFind(LTNode* phead, LTDataType x);
//pos位置前插入节点
void LTInsert(LTNode* pos, LTDataType x);
//pos位置删除节点
void LTErase(LTNode* pos);

->1.链表初始化
 

//链表初始化
LTNode* LTInIt()
{LTNode* phead = BuyListNode(-1);phead->prev = phead;phead->next = phead;return phead;
}

 因为这是带头双向循环链表，一开始我们得让哨兵位的头节点自己指向自己，这样就体现了带头双向循环的特性

如图：

->2.清空所有节点

//清空所有节点
//因为是一级指针的缘故所以在外面还得手动置空phead
void LTDestroy(LTNode* phead)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){LTNode* next = cur->next;free(cur);cur = next;}free(phead);
}

这里需要注意一点因为我们用的是一级指针所以出去之后我们还得手动指置空哨兵位的头节点（phead），这里有人就会问为什么不使用二级指针，因为大部分形参都是一级指针，我们就没必要去破坏整个代码的美观，非要在这里使用二级指针，除非必须要使用二级指针不可。这里断言一下phead，因为是带头的链表，所以传的头指针肯定不会为空，链表只要带头就不会出现空指针的情况


->3.判断链表中是否有其他节点(除了带哨兵位的头节点)

//判断链表中是否有其他节点(除了带哨兵位的头节点)
bool LTEmpty(LTNode* phead)
{assert(phead);/*if (phead->next == phead){return ture;}return false;*/return phead->next == phead;
}

因为在删除节点的时候，我们需要判断该链表中是否有节点可以删除，所以在这里我们单独做一个模块来判断。
 

->4.增加一个节点

//增加节点
LTNode* BuyListNode(LTDataType x)
{LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));if (NULL == newnode){perror("BuyListNode::malloc");exit(-1);}newnode->prev = NULL;newnode->data = x;newnode->next = NULL;return newnode;
}

->5.打印链表

//打印链表
void Print(LTNode* phead)
{assert(phead);LTNode* cur = phead->next;while (cur->next != phead){printf("%d ", cur->data);cur = cur->next;}printf("\n");
}

注意：这里需要将phead->next赋给cur，不然打印会将哨兵位中的值打印出来

->6.尾插

//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{assert(phead);LTNode* newnode = BuyListNode(x);LTNode* tail = phead->prev;tail->next = newnode;newnode->prev = tail;phead->prev = newnode;newnode->next = phead;
}

->7.尾删

//尾删
void LTPopBack(LTNode* phead)
{assert(phead);assert(!LTEmpty(phead));LTNode* tail = phead->prev;phead->prev = tail->prev;tail->prev->next = phead;
}


->8.头插

//头插
void LTPushFront(LTNode* phead, LTDataType x)
{assert(phead);LTNode* newnode = BuyListNode(x);LTNode* frist = phead->next; //将第一个元素的地址保存下来就不用考虑顺序了newnode->next = frist;frist->prev = newnode;phead->next = newnode;newnode->prev = phead;
}


->9.头删

//头删
void PopFront(LTNode* phead)
{assert(phead);assert(!LTEmpty(phead));LTNode* frist = phead->next;phead->next = frist->next;frist->next->prev = phead;free(frist);frist = NULL;
}

->10.查找节点地址

//查找节点地址
LTNode* LTFind(LTNode* phead, LTDataType x)
{assert(phead);LTNode* cur = phead;while (cur->next != phead){if (cur->data == x)return cur;cur = cur->next;}return NULL;
}


->11.pos位置前插入节点

//pos位置前插入节点
void LTInsert(LTNode* pos, LTDataType x)
{assert(pos);LTNode* newnode = BuyListNode(x);LTNode* posprev = pos->prev;posprev->next = newnode;newnode->prev = posprev;newnode->next = pos;pos->prev = newnode;
}

->12.pos位置删除节点

//pos位置删除节点
void LTErase(LTNode* pos)
{LTNode* posprev = pos->prev;LTNode* posnext = pos->next;posprev->next = posnext;posnext->prev = posprev;free(pos);pos = NULL;
}

1.7  带头双向循环链表的实现

List.h

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>typedef int LTDataType;typedef struct ListNode
{struct ListNode* prev;LTDataType data;struct ListNode* next;
}LTNode;//链表初始化
LTNode* LTInIt();
//清空链表
void LTDestroy(LTNode* phead);
//判断链表中是否有其他节点(除了带哨兵位的头节点)
bool LTEmpty(LTNode* phead);
//增加一个节点
LTNode* BuyListNode(LTDataType x);
//打印链表
void Print(LTNode* phead);//尾插
void LTPushBack(LTNode* phead, LTDataType x);
//尾删
void LTPopBack(LTNode* phead);
//头插
void LTPushFront(LTNode* phead, LTDataType x);
//头删
void LTPopFront(LTNode* phead);//查找节点地址
LTNode* LTFind(LTNode* phead, LTDataType x);
//任意位置插入节点
void LTInsert(LTNode* pos, LTDataType x);
//任意位置删除节点
void LTErase(LTNode* pos);

List.c

#include "List.h"//增加节点
LTNode* BuyListNode(LTDataType x)
{LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));if (NULL == newnode){perror("BuyListNode::malloc");exit(-1);}newnode->prev = NULL;newnode->data = x;newnode->next = NULL;return newnode;
}//链表初始化
LTNode* LTInIt()
{LTNode* phead = BuyListNode(-1);phead->prev = phead;phead->next = phead;return phead;
}//打印链表
void Print(LTNode* phead)
{assert(phead);LTNode* cur = phead->next;while (cur->next != phead){printf("%d ", cur->data);cur = cur->next;}printf("\n");
}//判断链表中是否有其他节点(除了带哨兵位的头节点)
bool LTEmpty(LTNode* phead)
{assert(phead);/*if (phead->next == phead){return ture;}return false;*/return phead->next == phead;
}//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{assert(phead);LTNode* newnode = BuyListNode(x);LTNode* tail = phead->prev;tail->next = newnode;newnode->prev = tail;phead->prev = newnode;newnode->next = phead;
}//尾删
void LTPopBack(LTNode* phead)
{assert(phead);assert(!LTEmpty(phead));LTNode* tail = phead->prev;phead->prev = tail->prev;tail->prev->next = phead;
}//头插
void LTPushFront(LTNode* phead, LTDataType x)
{assert(phead);LTNode* newnode = BuyListNode(x);LTNode* frist = phead->next; //将第一个元素的地址保存下来就不用考虑顺序了newnode->next = frist;frist->prev = newnode;phead->next = newnode;newnode->prev = phead;
}//头删
void PopFront(LTNode* phead)
{assert(phead);assert(!LTEmpty(phead));LTNode* frist = phead->next;phead->next = frist->next;frist->next->prev = phead;free(frist);frist = NULL;
}//清空所有节点
//因为是一级指针的缘故所以在外面还得手动置空phead
void LTDestroy(LTNode* phead)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){LTNode* next = cur->next;free(cur);cur = next;}free(phead);
}//查找节点地址
LTNode* LTFind(LTNode* phead, LTDataType x)
{assert(phead);LTNode* cur = phead;while (cur->next != phead){if (cur->data == x)return cur;cur = cur->next;}return NULL;
}//pos位置前插入节点
void LTInsert(LTNode* pos, LTDataType x)
{assert(pos);LTNode* newnode = BuyListNode(x);LTNode* posprev = pos->prev;posprev->next = newnode;newnode->prev = posprev;newnode->next = pos;pos->prev = newnode;
}//pos位置删除节点
void LTErase(LTNode* pos)
{LTNode* posprev = pos->prev;LTNode* posnext = pos->next;posprev->next = posnext;posnext->prev = posprev;free(pos);pos = NULL;
}

test.c

#include "List.h"int main()
{LTNode* plist = LTInIt();//尾插LTPushBack(plist, 1);LTPushBack(plist, 2);LTPushBack(plist, 3);LTPushBack(plist, 4);LTPushBack(plist, 5);Print(plist);//头插LTPushFront(plist, 6);Print(plist);//4前面插入LTNode* pos = LTFind(plist, 4);LTInsert(pos, 9);Print(plist);//删除2pos = LTFind(plist, 2);LTErase(pos);Print(plist);//尾删LTPopBack(plist);Print(plist);return 0;
}

测试结果：

1.8顺序表和链表的区别

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

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

相关文章

实战打靶集锦-31-monitoring

实战打靶集锦-31-monitoring

文章目录 1. 主机发现2. 端口扫描3. 服务枚举4. 服务探查4.1 ssh服务4.2 smtp服务4.3 http/https服务 5. 系统提权5.1 枚举系统信息5.2 枚举passwd文件5.3 枚举定时任务5.4 linpeas提权 6. 获取flag 靶机地址&#xff1a;https://download.vulnhub.com/monitoring/Monitoring.o…
阅读更多...
【BUG】已解决：python setup.py bdist_wheel did not run successfully.

【BUG】已解决：python setup.py bdist_wheel did not run successfully.

已解决&#xff1a;python setup.py bdist_wheel did not run successfully. 目录 已解决&#xff1a;python setup.py bdist_wheel did not run successfully. 【常见模块错误】 解决办法&#xff1a; 欢迎来到英杰社区https://bbs.csdn.net/topics/617804998 欢迎来到我的主…
阅读更多...
(二)原生js案例之数码时钟计时

(二)原生js案例之数码时钟计时

原生js实现的数字时间上下切换显示时间的效果&#xff0c;有参考相关设计&#xff0c;思路比较难&#xff0c;代码其实很简单 效果 代码实现 必要的样式 <style>* {padding: 0;margin: 0;}.content{/* text-align: center; */display: flex;align-items: center;justif…
阅读更多...
NOIP2015 推销员

NOIP2015 推销员

这里如果按照距离来考虑就太复杂了&#xff0c;于是转化对象&#xff0c;考虑客户 证明&#xff1a; 假设我们选的疲劳值最大的前X个的最远的一个的距离为 S 1 S_{1} S1​&#xff0c;那么可以知道&#xff0c;一定不会存在一个更优的方案&#xff0c;使得这个方案的最远的距离…
阅读更多...
（一）万字长文系列，redolog看这篇就够了 —— redolog的作用？写入方式是什么？什么是日志文件组？redolog的写入策略是怎样的？

（一）万字长文系列，redolog看这篇就够了 —— redolog的作用？写入方式是什么？什么是日志文件组？redolog的写入策略是怎样的？

导语 MySQL是一种广泛使用的开源关系型数据库管理系统&#xff0c;由瑞典公司MySQL AB开发&#xff0c;现由Oracle公司维护。它以其高性能、可靠性和易用性而著称&#xff0c;广泛应用于各种Web应用程序。MySQL支持多种操作系统&#xff0c;包括Windows、Linux和macOS&#xf…
阅读更多...
Kafka Producer发送消息流程之分区器和数据收集器

Kafka Producer发送消息流程之分区器和数据收集器

文章目录 1. Partitioner分区器2. 自定义分区器3. RecordAccumulator数据收集器 1. Partitioner分区器 clients/src/main/java/org/apache/kafka/clients/producer/KafkaProducer.java&#xff0c;中doSend方法&#xff0c;记录了生产者将消息发送的流程&#xff0c;其中有一步…
阅读更多...
【自动化测试】几种常见的自动化测试框架

【自动化测试】几种常见的自动化测试框架

在软件测试领域&#xff0c;自动化测试框架有很多&#xff0c;这里主要介绍几种常用的自动化测试框架。 1.pytest pytest 是 Python 的一种单元测试框架&#xff0c;与 Python 自带的 unittest 测试框架类似&#xff0c;但是比 unittest 框架使用起来更简洁&#xff0c;效率更高…
阅读更多...
UDP详细总结

UDP详细总结

UDP协议特点 UDP是无连接的传输层协议&#xff1b; UDP使用尽最大努力交付&#xff0c;不保证可靠交付&#xff1b; UDP是面向报文的&#xff0c;对应用层交下来的报文&#xff0c;不合并&#xff0c;不拆分&#xff0c;保留原报文的边界&#xff1b; UDP没有拥塞控制&#…
阅读更多...
[集成学习]基于python的Stacking分类模型的客户购买意愿分类预测

[集成学习]基于python的Stacking分类模型的客户购买意愿分类预测

1 导入必要的库 import pandas as pd import numpy as np import missingno as msno import matplotlib.pyplot as plt from matplotlib import rcParams import seaborn as sns from sklearn.metrics import roc_curve, auc from sklearn.linear_model import LogisticRegres…
阅读更多...
【C#】计算两条直线的交点坐标

【C#】计算两条直线的交点坐标

问题描述 计算两条直线的交点坐标&#xff0c;可以理解为给定坐标P1、P2、P3、P4&#xff0c;形成两条线&#xff0c;返回这两条直线的交点坐标&#xff1f; 注意区分&#xff1a;这两条线是否垂直、是否平行。 代码实现 斜率解释 斜率是数学中的一个概念&#xff0c;特别是…
阅读更多...
改变你对文本生成程序的误解！用C++标准库，MinGW情况下，写一个文本生成器(一种AI)

改变你对文本生成程序的误解！用C++标准库，MinGW情况下，写一个文本生成器(一种AI)

声明：我这个不是那种“文本生成器” 我之前见过那种“自动写作文”的程序，无非就是这样的文章： 文章写的只有主题，没有内容 我曾多次向我的朋友提问他们看没看过那种AI写作的代码，而给我的回复很简单：你弄那玩楞干哈？装*？那玩楞我见过，写的文章空有其表，没有其实；…
阅读更多...
Java并发04之线程同步机制

Java并发04之线程同步机制

文章目录 1 线程安全1.1 线程安全的变量1.2 Spring Bean1.3 如果保证线程安全 2 synchronized关键字2.1 Java对象头2.1.1 对象组成部分2.1.2 锁类型2.1.3 锁对象 2.2 synchronized底层实现2.2.1 无锁状态2.2.2 偏向锁状态2.2.3 轻量级锁状态2.2.4 重量级锁2.2.5 锁类型总结2.2.…
阅读更多...
windows USB 设备驱动开发-编写 UCSI 客户端驱动程序

windows USB 设备驱动开发-编写 UCSI 客户端驱动程序

编写 UCSI 客户端驱动程序 USB Type-C 连接or 系统软件接口&#xff08;UCSI&#xff09;驱动程序充当带有嵌入式控制器&#xff08;EC&#xff09;的 USB Type-C 系统的控制器驱动程序。 如果实现平台策略管理器&#xff08;PPM&#xff09;的系统&#xff0c;如 UCSI 规范中…
阅读更多...
国产化低功耗HDMI转VGA方案，大量出货产品，广泛应用在显示器以及广告机产品

国产化低功耗HDMI转VGA方案，大量出货产品，广泛应用在显示器以及广告机产品

芯片描述&#xff1a; 兼具高性能和低成本效益的优点&#xff0c;是一款可以将高清视频 HDMI1.4 数字信号转换成 VGA 模拟信号输出的芯片。不需要提供外部电源&#xff0c;ICNM7301 就可以在正常模式下使用&#xff1b;ICNM7301 广 泛适用于各种市场系统和显示应用体系&#x…
阅读更多...
LabVIEW异步和同步通信详细分析及比较

LabVIEW异步和同步通信详细分析及比较

1. 基本原理 异步通信&#xff1a; 原理&#xff1a;异步通信&#xff08;Asynchronous Communication&#xff09;是一种数据传输方式&#xff0c;其中数据发送和接收操作在独立的时间进行&#xff0c;不需要在特定时刻对齐。发送方在任何时刻可以发送数据&#xff0c;而接收…
阅读更多...
2024年广东省安全员B证第四批（项目负责人）证模拟考试题库及广东省安全员B证第四批（项目负责人）理论考试试题

2024年广东省安全员B证第四批（项目负责人）证模拟考试题库及广东省安全员B证第四批（项目负责人）理论考试试题

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 2024年广东省安全员B证第四批&#xff08;项目负责人&#xff09;证模拟考试题库及广东省安全员B证第四批&#xff08;项目负责人&#xff09;理论考试试题是由安全生产模拟考试一点通提供&#xff0c;广东省安全员B证…
阅读更多...
手持式气象站：便携科技，掌握微观气象的利器

手持式气象站：便携科技，掌握微观气象的利器

手持式气象站&#xff0c;顾名思义&#xff0c;是一种可以随身携带的气象监测设备。它小巧轻便&#xff0c;通常配备有温度、湿度、风速、风向、气压等多种传感器&#xff0c;能够实时测量并显示各种气象参数。不仅如此&#xff0c;它还具有数据存储、数据传输、远程控制等多种…
阅读更多...
kafka开启kerberos和ACL

kafka开启kerberos和ACL

作者&#xff1a;恩慈 一、部署kafka-KB包 1&#xff0e;上传软件包 依次点击 部署中心----部署组件----上传软件包 选择需要升级的kafka版本并点击确定 2&#xff0e;部署kafka 依次点击部署中心----部署组件----物理/虚拟机部署----选择集群----下一步 选择手动部署-…
阅读更多...
MongoDB自学笔记（四）

MongoDB自学笔记（四）

一、前文回顾 上一篇文章中我们学习了MongoDB中的更新方法&#xff0c;也学了一部分操作符。今天我们将学习最后一个操作“删除”。 二、删除 原始数据如下&#xff1a; 1、deleteOne 语法&#xff1a;db.collection.deleteOne(< query >,< options >) 具体参…
阅读更多...
学生信息管理系统-可视化-科目管理CRUD代码生成器

学生信息管理系统-可视化-科目管理CRUD代码生成器

学生管理系统中的科目管理是一个重要的组成部分&#xff0c;它负责维护和管理学校中所有的教学科目信息。 可视化快速界面生成CRUD界面&#xff0c;API通过代码生成器生成器生成。 新增数据库表 拷贝demo_table修改为clazz_kemu表 修改表结构 其中包括一个自增ID字段&#x…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023