【数据结构 · 初阶】- 单链表

目录

一.相关指针知识点

二.链表

1.为什么学了顺序表还要学链表

2.优点

三.实现

1.链表的打印 —— 理解链表结构

(2) 物理结构图

2.链表的尾插 —— 入门

错误写法：tail != NULL

总结：

正确代码物理图解：

(2) 尾插整体代码 (思考对吗?)

Bug

3.头插

4.尾删

Bug

5.头删

6.查找

7. Find 查找的功能

（1）pos 之前插入

（2）pos 位置删除

（3）pos 之后插入

（4）pos位置后面删除

 8.销毁

 四.思维提升

五.总结

1.传什么？

2.要不要断言？

（1）打印、查找

（2）pphead

（3）*pphead

六.整体代码

SList.h

SList.c

一.相关指针知识点

调用一个函数，就会建立一个空间，这个空间叫栈帧。局部变量是存放在栈帧里的（除了static修饰的局部变量）。函数结束，栈帧空间就销毁，局部变量也销毁

函数传参，不管是传值，还是传地址，其实都是拷贝。就看拷贝值还是地址。

代码1：y 的改变，不会改变 x 的值

void Func(int y)
{y = 1;
}
int main()
{int x = 0;Func(x);return 0;
}

这是两个栈帧，Func 里面是 y，main 里面是 x。x 传给 y 是拷贝给 y，y 的改变不会影响 x，并且 Func 会销毁

代码2：解决上面问题，传地址。改变的是 int ，使用的是 int 的指针

void Func(int* p)
{*p = 1;
}
int main()
{int x = 0;Func(&x);return 0;
}

这里的 p 是 x 地址的拷贝。在传参里面，我们要改变什么，就要用它的指针。然后 * 解引用可以改变

代码3：

void Func(int* ptr)
{ptr = (int*)malloc(sizeof(int));
}
int main()
{int* px = NULL;Func(px);free(px); // 加上也没用return 0;
}

这也是拷贝值，把 px 的值拷贝给 ptr，ptr 是空。但是我 malloc 了一块空间，让 ptr 指向这块空间。
px 拷贝给 ptr，ptr 的改变不会影响 px 。并且出了作用域 Func 销毁，malloc 的内存块还找不到了（内存泄漏），就算 free 也 free 不到

这里我们要改变的是 int* ，不是 int 。传 int* 不起作用。应该传 int**（二级指针）

代码4：改变 int* ，使用 int* 的地址，int**（二级指针）

void Func(int** pptr)
{*pptr = (int*)malloc(sizeof(int));
}
int main()
{int* px = NULL;Func(&px);free(px);return 0;
}

这里把 px 的地址传过去，pptr 指向 px 。malloc了一块空间，是让 *pptr 即 px 指向这块空间
Func 结束，栈帧销毁。但 px 还指向这块空间，free 可以 free 到。这里内存释放，值也拿回来了

二.链表

1.为什么学了顺序表还要学链表

顺序表是有很多缺陷的：
（1）中间,头部 插入,删除数据，需要挪动数据，效率低下。你也不可能说在中间插入一块空间，没有这种概念，这本来就是一块连续的空间。
（2）空间不够需要扩容，拷贝数据，释放旧空间。会有不小的消耗
扩容有一定的效率消耗。原地扩还好，异地扩呢？
还可能会有一定的空间浪费。一次扩太少，会频繁扩；一次扩太多，浪费

能不能说，我用一点给一点呢？存一块数据，开一块空间
可以，但怎么管理呢？
顺序表里，开了整片空间，由于存放的数据是连续的，只需要记录这块空间最开始的地址。
现在要一块空间，去 malloc 。多次 malloc ，他们之间的地址不能保证相邻。

这时候，链表会用一个指针指向第一个内存块（节点 Node）。
为了通过第一个能找到第二个怎么办？上一个会存下一个的地址，上一个指向下一个。
什么时候结束？顺序表是 size 。链表里最后一个节点的指针存 NULL 即可

2.优点

不需要扩容。存一块，开一块。
可以从中间插入，不需要挪动数据。

顺序表，链表是互补，相辅相成的。很多情况是配合起来使用的

三.实现

上面的理解，链表是一个个的内存块，再由指针链接起来
先来定义它的结构：从语言的角度来说，凡是有多个数据，都要存到结构体里面
为方便替换成其他类型的数据，我们将类型统一重命名为 SLTDataType

1.链表的打印 —— 理解链表结构

SList.h

上一个节点要存下一个节点的地址，每个节点都是结构体类型，所以存结构体指针 next
链表要有个头指针 phead 指向第一个节点，判断结束只需要走到空 NULL 即可。
不能断言 phead 为空，空链表也可以打印

typedef int SLTDataType;typedef struct SListNode
{SLTDataType data;struct SListNode* next;
}SLTNode;//打印链表
void SLTPrint(SLTNode* phead);

SList.c

void SLTPrint(SLTNode* phead)
{SLTNode* cur = phead;//while (cur->next != NULL) 错误写法！！！//while(cur != NULL)while (cur){printf("%d->", cur->data);cur = cur->next; // 指向下一个位置// 不能写成 ++cur;}printf("NULL\n");
}

问：为什么不能写成 ++cur ？
答：链表地址不连续，++cur 不能保证它指向下一个位置。如果强行把地址弄成连续，不就成顺序表了吗？

怎么理解 cur = cur->next；
cur 是结构体指针，cur-> 就是访问结构体成员。next 是结构体成员，是下一个节点的地址
赋值操作是把下一个节点的地址给 cur 

为什么循环判断条件 cur->next != NULL 为错？
cur->next 是下一节点地址。走到尾就结束了，没有打印最后的数据

(2) 物理结构图

上面画的是逻辑结构图，是为方便理解，形象画出来的
物理结构图：实实在在数据在内存中的变化

2.链表的尾插 —— 入门

依然不能断言 phead 为空。为空（没有数据）依然可以尾插

顺序表尾插，先要判断空间够不够，不够扩容。      链表不用，永远有空间

第一步：搞个节点，并初始化。后面多次用到，分装成函数
第二步：找尾。  尾的特征：tail->next == NULL

// 搞节点，并初始化
SLTNode* BuySLTNode(SLTDataType x)
{SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));if (newnode == NULL){perror("malloc fail");return NULL;}// 初始化newnode->data = x;newnode->next = NULL;return newnode;
}void SLTPushBack(SLTNode* phead, SLTDataType x) // 思考这里对吗？
{SLTNode* newnode = BuySLTNode(x);// 找尾SLTNode* tail = phead;while (tail->next != NULL){tail = tail->next;}tail->next = newnode;
}

错误写法：tail != NULL

// 找尾
SLTNode* tail = phead;
while (tail != NULL)
{tail = tail->next;
}
tail = newnode;

从逻辑结构图角度，看似正确：

从物理结构图理解：

tail ，newnode 都是局部变量，出了作用域销毁

上一个节点没有存下一个节点的地址，链接失败

总结：

tail 是个局部变量。不应该赋值给 tail 。应该赋值给 tail 指向的结构体(存放下一个节点地址的)成员

不为空链表尾插的本质：原尾节点中要存新的尾节点的地址

正确代码物理图解：

// 找尾
SLTNode* tail = phead;
while (tail->next != NULL)
{tail = tail->next;
}
tail->next = newnode;

tail ，newnode 都是局部变量，出了作用域销毁

上一个节点存储下一个节点的地址，链接成功

(2) 空链表尾插

phead == NULL      tail = phead        让 phead 指向新节点即可

(2) 尾插整体代码 (思考对吗?)

SList.h

typedef int SLTDataType;typedef struct SListNode
{SLTDataType data;struct SListNode* next;
}SLTNode;//打印链表
void SLTPrint(SLTNode* phead);
//尾插
void SLTPushBack(SLTNode* phead, SLTDataType x); // 思考这里对不对

SList.c 

void SLTPushBack(SLTNode* phead, SLTDataType x) // 对吗？
{SLTNode* newnode = BuySLTNode(x);if (phead == NULL){phead = newnode;}else{// 找尾SLTNode* tail = phead;while (tail->next != NULL){tail = tail->next;}tail->next = newnode;}
}

Test.c

void TestSList1()
{SLTNode* plist = NULL;SLTPushBack(plist, 1);SLTPushBack(plist, 2);SLTPushBack(plist, 3);SLTPushBack(plist, 4);SLTPrint(plist);
}

Bug

我们运行上面的代码：

看下图，phead 和 newnode 都是结构体指针类型的指针变量
phead = newnode 是赋值行为，其真正含义是让 phead 也指向 newnode 指向的新节点

函数结束，栈帧空间销毁。我们的目标是让 plist 指向新节点，但最后没有，造成了内存泄漏

改Bug

我们要改变 SLNode* plist ，传参里要传 SLNode* plist 的地址 ，用 SLNode** 接收

SList.h

typedef int SLTDataType;typedef struct SListNode
{SLTDataType data;struct SListNode* next;
}SLTNode;//打印链表
void SLTPrint(SLTNode* phead);
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);

SList.c

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

pphead 存的是 plist 的指针。*pphead 就是 plist 。
函数结束，栈帧空间销毁。plist 指向了新节点

链表运行结果：

3.头插

盲猜头插要用二级指针，因为一定有一个情况是为空，为空肯定要用

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

如果传的是 phead ，改变的就是 phead ，无法改变外边的 plist

这段代码同样可以解决空的情况

4.尾删

SList.c

void SLTPopBack(SLTNode** pphead) // 这么写对吗？
{assert(pphead);assert(*pphead);// 找尾SLTNode* tail = *pphead;while (tail->next != NULL){tail = tail->next;}free(tail);tail = NULL;
}

Test.c

void TestSList1()
{SLTNode* plist = NULL;SLTPushFront(&plist, 1);SLTPushFront(&plist, 2);SLTPushFront(&plist, 3);SLTPushFront(&plist, 4);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);
}

Bug

     碰上这种情况多半是野指针，调试看看

尾就是1这个节点，2这个节点存着他的地址

直接把 tail 指向的尾节点 free 了，前一个节点的 next 就是野指针了。指向已经被释放的空间的指针是野指针

这里把 tail 置空，不会把前一个节点的 next 置空
前一个节点是结构体，想改变结构体的内容要用结构体指针

修改1

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

修改2：找的是倒数第2个

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;
}

如果链表删到只剩1个元素，还删。
如果链表本身为空

void TestSList1()
{SLTNode* plist = NULL;SLTPushFront(&plist, 1);SLTPushFront(&plist, 2);SLTPushFront(&plist, 3);SLTPushFront(&plist, 4);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);
}

              

下面用红圈圈起来的是两组代码在只剩1个的情况下，分别有误的地方

修改：只有1个节点，直接 free，plist 置空。不用找尾节点
所以尾删如果用一级指针接收，phead 是 plist 的拷贝，对 phead 置空的改变不影响 plist，达不到置空 plist 的目的，plist 会变成野指针

void SLTPopBack(SLTNode** pphead)
{//暴力检查assert(pphead);assert(*pphead);//温柔检查/*if (*pphead == NULL)return;*/if ((*pphead)->next == NULL) // 只有1个节点{free(*pphead);*pphead = NULL;}else // 多个节点{/*SLTNode* prev = NULL;// 找尾SLTNode* tail = *pphead;while (tail->next != NULL){prev = tail;tail = tail->next;}free(tail);tail = NULL;prev->next = NULL;*/// 找尾SLTNode* tail = *pphead;while (tail->next->next != NULL){tail = tail->next;}free(tail->next);tail->next = NULL;}
}

5.头删

不需要单独处理只有1个节点的情况

void SLTPopFront(SLTNode** pphead)
{assert(pphead);assert(*pphead);SLTNode* first = *pphead;*pphead = first->next;free(first);first = NULL;
}

6.查找

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{SLTNode* cur = phead;while (cur){if (cur->data == x){return cur;}cur = cur->next;}return NULL;
}

返回的是对应节点的指针，可以用 Find 实现修改

void TestSList2()
{SLTNode* plist = NULL;SLTPushFront(&plist, 1);SLTPushFront(&plist, 2);SLTPushFront(&plist, 3);SLTPushFront(&plist, 4);SLTPrint(plist);// 值为2的节点 *2SLTNode* ret = SLTFind(plist, 2);ret->data *= 2;SLTPrint(plist);
}

Find 主要是与下面的功能相配合

7. Find 查找的功能

我们这里不传下标，传结构体指针，与 C++ 贴合

（1）pos 之前插入

为啥不是在 pos 位置插入？ 是把 pos 及以后的数据往后移，所以逻辑上说是之前插入

单链表不适合 pos 之前插入，只适合在后面插入，因为要找到 pos 前一个节点的地址，只能从头找

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{if (pos == *pphead){SLTPushFront(pphead, x);}else{// 找到 pos 的前一个位置SLTNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}SLTNode* newnode = BuySLTNode(x);newnode->next = pos;prev->next = newnode;}
}

如果 pos 不是链表里的指针，while 循环停不下来，最终出现空指针
这种情况怎么办 (甚至 pos 就是 NULL)？   
说明传错了，断言，起码可以排除 NULL

（2）pos 位置删除

这里 *pphead 可以不断言，pos 间接断言了
pos 不为空，有节点，一定不为空链表

pos 位删除，要找到前一个位置。pos 是头，就是头删，先处理这个特殊情况

void SLTErase(SLTNode** pphead, SLTNode* pos)
{assert(pphead);assert(pos);assert(*pphead);if (*pphead == pos){SLTPopFront(pphead);}else{// 找到 pos 的前一个位置SLTNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}prev->next = pos->next;free(pos);// pos = NULL;}
}

pos = NULL 没用，形参的修改不改变实参。要不要传二级指针呢？不。
为保持和其他的一致性，通常由用的人考虑置空

void TestSList4()
{SLTNode* plist = NULL;SLTPushFront(&plist, 1);SLTPushFront(&plist, 2);SLTPushFront(&plist, 3);SLTPushFront(&plist, 4);SLTPrint(plist);SLTNode* ret = SLTFind(plist, 2);SLTErase(&plist, ret);ret = NULL;SLTPrint(plist);
}

（3）pos 之后插入

错误写法：会造成死循环

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{assert(pos);SLTNode* newnode = BuySLTNode(x);pos->next = newnode;newnode->next = pos->next;
}

正确写法：先改后面

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{assert(pos);SLTNode* newnode = BuySLTNode(x);newnode->next = pos->next;pos->next = newnode;
}

（4）pos位置后面删除

法1：pos->next = pos->next->next;  这里从右往左赋值     橙圈的内容丢了，所以要引入del

void SLTEraseAfter(SLTNode* pos)
{assert(pos);assert(pos->next);SLTNode* del = pos->next;pos->next = pos->next->next;free(del);del = NULL;
}

法2：好理解

void SLTEraseAfter(SLTNode* pos)
{assert(pos);assert(pos->next);SLTNode* del = pos->next;pos->next = del->next;free(del);del = NULL;
}

 8.销毁

写法1：一级指针

void SLTDestroy(SLTNode* phead); // SList.hvoid SLTDestroy(SLTNode* phead)
{SLTNode* cur = phead;while (cur){SLTNode* tmp = cur->next;free(cur);cur = tmp;}// phead = NULL;
}

phead = NULL 没用，形参的修改不改变实参。让用的人置空

void TestSList4()
{SLTNode* plist = NULL;......SLTDestroy(plist);plist = NULL;
}

写法2：二级指针    自己置空

void SLTDestroy(SLTNode** pphead); // SList.hvoid SLTDestroy(SLTNode** pphead)
{assert(pphead);SLTNode* cur = *pphead;while (cur){SLTNode* tmp = cur->next;free(cur);cur = tmp;}*pphead = NULL;
}SLTDestroy(&plist); // Test.c

 四.思维提升

单链表给了 pos 没给头指针

（1）插入

（2）删除

没有前一个位置，就删后一个。先换值，后删。但是不能删尾

五.总结

1.传什么？

我们刚开始拿到链表，plist 是 NULL 。要插入新节点，要让 plist 指向新节点，会改变 plist ，所以要传指针的地址。
删除时，总会删到空，这时要将 plist 置为 NULL ，也改变 plist ，所以也传指针的地址

如果不需要修改头指针的链接，就传一级指针

2.要不要断言？

断言可以排出明显的错误，避免调试耗时。一定不能为空，就断言

（1）打印、查找

问：是否要 assert 指针 phead 为空？ （一级指针）
答：不要。空的 (没有数据) 的链表，顺序表都可以打印、查找。链表为空时，phead == NULL，断言直接终止程序不合适。

顺序表，链表结构不一样，不能一概而论。
phead 是指向第一个存有数据的节点，链表为空时，phead == NULL

顺序表的打印


void SLPrint(SL* ps)
{assert(ps);for (int i = 0; i < ps->size; ++i){printf("%d ", ps->a[i]);}printf("\n");
}

指针 ps 指向结构体 SL ，顺序表的数据不是存储在结构体上。而是存储在结构体里的一个指针 a 指向的空间。即使顺序表里没有数据，ps 指向的结构体也是必须要有的。ps->a 是否为空也不重要，到底有没有数据，取决于 ps->size 是否为 0
所以对顺序表而言，指针就不能为空

总结：不要看到指针上来就断言

（2）pphead

要，pphead 不能为空。为什么？
pphead 是 plist 的地址。plist 是指针变量，值有可能是空，地址一定不为空

（3）*pphead

*pphead 就是 plist ，是看是否为空 （二级指针）

要不要断言 *pphead 取决于函数是否包容空链表的情况

先 assert ( pphead )   后 assert ( *pphead )  如果反了，先 * ，再检查，有啥用？

空链表能插入，不断言；不能删，要断言。

六.整体代码

SList.h

#pragma once
#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); // 打印链表
void SLTPushBack(SLTNode** pphead, SLTDataType x); // 尾插
void SLTPushFront(SLTNode** pphead, SLTDataType x); // 头插void SLTPopBack(SLTNode** pphead); // 尾删
void SLTPopFront(SLTNode** pphead); // 头删SLTNode* SLTFind(SLTNode* phead, SLTDataType x); // 查找void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x); // pos之前插入
void SLTErase(SLTNode** pphead, SLTNode* pos); // pos位置删除void SLTInsertAfter(SLTNode* pos, SLTDataType x); // pos之后插入
void SLTEraseAfter(SLTNode* pos); // pos位置后面删除//void SLTDestroy(SLTNode* phead); // 链表销毁
void SLTDestroy(SLTNode** pphead); // 链表销毁

SList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"void SLTPrint(SLTNode* phead)
{SLTNode* cur = phead;//while (cur->next != NULL) 错误写法！！！//while(cur != NULL)while (cur){printf("%d->", cur->data);cur = cur->next;//cur++; 错误写法！！！}printf("NULL\n");
}// 搞新节点，并初始化
SLTNode* BuySLTNode(SLTDataType x)
{SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));if (newnode == NULL){perror("malloc fail");return NULL;}// 初始化newnode->data = x;newnode->next = NULL;return newnode;
}void SLTPushBack(SLTNode** pphead, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuySLTNode(x);if (*pphead == NULL){*pphead = newnode;}else{// 找尾SLTNode* tail = *pphead;while (tail->next != NULL){tail = tail->next;}tail->next = newnode;}
}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);//温柔检查/*if (*pphead == NULL)return;*/if ((*pphead)->next == NULL) // 只有1个节点{free(*pphead);*pphead = NULL;}else // 多个节点{/*SLTNode* prev = NULL;// 找尾SLTNode* tail = *pphead;while (tail->next != NULL){prev = tail;tail = tail->next;}free(tail);tail = NULL;prev->next = NULL;*/// 找尾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)
{SLTNode* cur = phead;while (cur){if (cur->data == x){return cur;}cur = cur->next;}return NULL;
}void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{assert(pphead);assert(pos);if (pos == *pphead){SLTPushFront(pphead, x);}else{// 找到 pos 的前一个位置SLTNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}SLTNode* newnode = BuySLTNode(x);newnode->next = pos;prev->next = newnode;}
}void SLTErase(SLTNode** pphead, SLTNode* pos)
{assert(pphead);assert(pos);assert(*pphead);if (*pphead == pos){SLTPopFront(pphead);}else{// 找到 pos 的前一个位置SLTNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}prev->next = pos->next;free(pos);// pos = NULL;}
}void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{assert(pos);SLTNode* newnode = BuySLTNode(x);newnode->next = pos->next;pos->next = newnode;
}void SLTEraseAfter(SLTNode* pos)
{assert(pos);assert(pos->next);//SLTNode* del = pos->next;//pos->next = pos->next->next;//free(del);//del = NULL;SLTNode* del = pos->next;pos->next = del->next;free(del);del = NULL;
}/*
void SLTDestroy(SLTNode* phead)
{SLTNode* cur = phead;while (cur){SLTNode* tmp = cur->next;free(cur);cur = tmp;}
}
*/void SLTDestroy(SLTNode** pphead)
{assert(pphead);SLTNode* cur = *pphead;while (cur){SLTNode* tmp = cur->next;free(cur);cur = tmp;}*pphead = NULL;
}

本篇的分享就到这里了，感谢观看，如果对你有帮助，别忘了点赞+收藏+关注。
小编会以自己学习过程中遇到的问题为素材，持续为您推送文章

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

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

相关文章

按键消抖（用状态机实现）

按键消抖（用状态机实现）

基于状态机的设计代码 module key_filter(clk,rst,key,key_p_flag,key_r_flag,key_state);input clk,rst;input key;output reg key_p_flag;output reg key_r_flag;output reg key_state;reg [1:0]r_key; //后面用来判断什么时候pedge&#xff0c;什么时候nedgealways…
阅读更多...
大数据（7.2）Kafka万亿级数据洪流下的架构优化实战：从参数调优到集群治理

大数据（7.2）Kafka万亿级数据洪流下的架构优化实战：从参数调优到集群治理

目录 一、海量数据场景下的性能之殇1.1 互联网企业的数据增长曲线1.2 典型性能瓶颈分析 二、生产者端极致优化2.1 批量发送黄金法则2.1.1 分区选择算法对比 2.2 序列化性能突破 三、消费者端并发艺术3.1 多线程消费模式演进3.1.1 消费组Rebalance优化 3.2 位移管理高阶技巧 四、…
阅读更多...
MyBatis深度解析与实战指南：细节完整，从入门到精通

MyBatis深度解析与实战指南：细节完整，从入门到精通

MyBatis深度解析与实战指南&#xff1a;细节完整&#xff0c;从入门到精通 整理这份笔记&#xff0c;是因为学习 MyBatis 时发现很多教程要么只讲基础 CRUD&#xff0c;要么直接跳到 Spring 整合&#xff0c;对 MyBatis 核心特性讲解不全面&#xff0c;基础部分也不够完整。实…
阅读更多...
【科学技术部政务服务平台-用户注册/登录安全分析报告】

【科学技术部政务服务平台-用户注册/登录安全分析报告】

前言 由于网站注册入口容易被黑客攻击&#xff0c;存在如下安全问题&#xff1a; 暴力破解密码&#xff0c;造成用户信息泄露短信盗刷的安全问题&#xff0c;影响业务及导致用户投诉带来经济损失&#xff0c;尤其是后付费客户&#xff0c;风险巨大&#xff0c;造成亏损无底洞…
阅读更多...
【Audio开发三】音频audio中帧frameSize ，周期大小periodsize，缓冲区buffer原理详解以及代码流程分析

【Audio开发三】音频audio中帧frameSize ，周期大小periodsize，缓冲区buffer原理详解以及代码流程分析

一、基础概述 在分析获取最小帧数前&#xff0c;我们先来了解几个相关的概念。 1&#xff0c;帧 帧&#xff08;frame&#xff09;&#xff1a;表示一个完整的声音单元&#xff0c;所谓的声音单元是指一个采样样本。如果是双声道&#xff0c;那么一个完整的声音单元就是 2 个样…
阅读更多...
K8S学习之基础七十五：istio实现灰度发布

K8S学习之基础七十五：istio实现灰度发布

istio实现灰度发布 上传镜像到harbor 创建两个版本的pod vi deployment-v1.yaml apiVersion: apps/v1 kind: Deployment metadata:name: appv1labels:app: v1 spec:replicas: 1selector:matchLabels:app: v1apply: canarytemplate:metadata:labels:app: v1apply: canaryspec…
阅读更多...
C++蓝桥杯填空题（攻克版）

C++蓝桥杯填空题（攻克版）

片头 嗨~小伙伴们&#xff0c;咱们继续攻克填空题&#xff0c;先把5分拿到手~ 第1题 数位递增的数 这道题&#xff0c;需要我们计算在整数 1 至 n 中有多少个数位递增的数。 什么是数位递增的数呢&#xff1f;一个正整数如果任何一个数位不大于右边相邻的数位。比如&#xf…
阅读更多...
【Python】数据结构

【Python】数据结构

【Python】数据结构&#xff1a; Series&#xff1a;1、通过列表创建Series类对象2、显示地给数据指定标签索引3、通过字典创建Series类对象4、获取索引5、获取数据 DataFrame&#xff1a;1、通过数组创建一个DataFrame类对象2、指定列索引3、指定行索引4、获取列的数据5、查看…
阅读更多...
Android XML布局与Compose组件对照手册

Android XML布局与Compose组件对照手册

下面我将详细列出传统 XML 布局中的组件与 Compose 组件的对应关系&#xff0c;帮助您更好地进行迁移或混合开发。 基础布局对应 XML 布局Compose 组件说明LinearLayout (vertical)Column垂直排列子项LinearLayout (horizontal)Row水平排列子项FrameLayoutBox层叠子项Relativ…
阅读更多...
云原生运维在 2025 年的发展蓝图

云原生运维在 2025 年的发展蓝图

随着云计算技术的不断发展和普及&#xff0c;云原生已经成为了现代应用开发和运维的主流趋势。云原生运维是指在云原生环境下&#xff0c;对应用进行部署、监控、管理和优化的过程。在 2025 年&#xff0c;云原生运维将迎来更加广阔的发展前景&#xff0c;同时也将面临着一系列…
阅读更多...
js day5

js day5

复习模板字符串&#xff1a; 在输出语句里面 document.write(我今年${a}岁了)中间是反引号&#xff1b;里面是${变量}&#xff1b; 复习基本类型 number String null undefined boolean 检测数据类型输出typedf 变量则可&#xff1b; 添加链接描述 复习样式变量table什么的边…
阅读更多...
SmolVLM2: The Smollest Video Model Ever（三）

SmolVLM2: The Smollest Video Model Ever（三）

这是对《SmolLM2: When Smol Goes Big — Data-Centric Training of a Small Language Model》的翻译阅读 摘要 虽然大语言模型在人工智能的许多应用中取得了突破&#xff0c;但其固有的大规模特性使得它们在计算上成本高昂&#xff0c;并且在资源受限的环境中部署具有挑战性。…
阅读更多...
汽车软件开发常用的需求管理工具汇总

汽车软件开发常用的需求管理工具汇总

目录 往期推荐 DOORS&#xff08;IBM &#xff09; 行业应用企业&#xff1a; 应用背景&#xff1a; 主要特点&#xff1a; Polarion ALM&#xff08;Siemens&#xff09; 行业应用企业&#xff1a; 应用背景&#xff1a; 主要特点&#xff1a; Codebeamer ALM&#x…
阅读更多...
爬虫工程师杂活工具人

爬虫工程师杂活工具人

30岁的年龄;这个年龄大家都是成年人;都是做父母的年龄了;你再工位上的心态会发生很大变化的; 爬虫工程师基本都是如此;社会最low的一帮连销售都做不了的;单子都开不出来的然后转行做爬虫工程师的;这样的人基本不太和社会接触; 你作为爬虫初级工程师就敲着键盘然后解析着html;…
阅读更多...
如何使用Tomcat

如何使用Tomcat

1 简介 Tomcat是Apache 软件基金会&#xff08;Apache Software Foundation&#xff09;的Jakarta 项目中的一个核心项目&#xff0c;由Apache、Sun 和其他一些公司及个人共同开发而成。因为Tomcat 技术先进、性能稳定&#xff0c;而且免费&#xff0c;成为目前比较流行的Web 应…
阅读更多...
【AI工具】FastGPT：开启高效智能问答新征程

【AI工具】FastGPT：开启高效智能问答新征程

前言 在人工智能飞速发展的当下&#xff0c;各类 AI 工具如雨后春笋般涌现。FastGPT 作为一款基于大语言模型&#xff08;LLM&#xff09;的知识图谱问答系统&#xff0c;凭借其强大的数据处理和模型调校能力&#xff0c;为用户带来了便捷的使用体验。今天&#xff0c;就让我们…
阅读更多...
14. git remote

14. git remote

基本概述 git remote 的作用是&#xff1a;查看、添加、修改和删除与本地仓库关联的远程仓库。 基本用法 1.查看远程仓库 git remote # 显示所有关联的远程仓库&#xff08;名称&#xff09; git remote -v # 显示所有关联的远程仓库&a…
阅读更多...
【spark-submit】--提交任务

【spark-submit】--提交任务

Spark-submit spark-submit 是 Apache Spark 提供的用于提交 Spark 应用程序到集群的命令行工具。 基本语法 spark-submit [options] <app-jar> [app-arguments]常用参数说明 应用程序配置 --class <class-name>: 指定应用程序的主类&#xff08;对于 Java/Sc…
阅读更多...
2025.4.10总结

2025.4.10总结

今日记录&#xff1a;今天提了两个问题单&#xff0c;最近要关注一下产出了&#xff0c;上半年的考核如今还剩两个月了&#xff0c;然后发现一同入职的同事&#xff0c;有的人进步得很快&#xff0c;得向优秀得同事看齐了&#xff0c;不然几年过去&#xff0c;别人连升好几年&a…
阅读更多...
SvelteKit 最新中文文档教程（18）—— 浅层路由和 Packaging

SvelteKit 最新中文文档教程（18）—— 浅层路由和 Packaging

前言 Svelte&#xff0c;一个语法简洁、入门容易&#xff0c;面向未来的前端框架。 从 Svelte 诞生之初&#xff0c;就备受开发者的喜爱&#xff0c;根据统计&#xff0c;从 2019 年到 2024 年&#xff0c;连续 6 年一直是开发者最感兴趣的前端框架 No.1&#xff1a; Svelte …
阅读更多...
最新文章

Copyright @ 2022~2023