学习记录day16—— 数据结构 双向链表 循环链表

双向链表

1、概念

        1）就是从任意一个节点既能存储其前驱节点，又能存储后继节点

        2)结构体中增加一个指向前驱节点的指针

//定义数据类型
typedef int datatype;//定义节点类型
typedef struct Node
{union {int len;datatype data;};struct Node *prio; struct Node *next; };

        3）头节点没有前驱，最后一个节点没有后继

2、创建虚拟链表

// 创建链表
NodePtr list_create()
{// 在堆区申请一个头节点NodePtr L = (NodePtr)malloc(sizeof(Node));if (NULL == L){printf("创建失败\n");return NULL;}L->len = 0;L->next = NULL;L->prio = NULL;printf("链表创建成功\n");return L;
}

3、申请封装数据

// 申请封装数据
NodePtr apply_node(datatype e)
{NodePtr p = (NodePtr)malloc(sizeof(Node));if (NULL == p){printf("数据类型不合法,封装失败\n");return NULL;}p->data = e;p->prio = NULL;p->next = NULL;return p;
}

4、判空

// 判空
int list_empty(NodePtr L)
{return L->next == NULL;
}

5、头插

// 头插
int list_insert_head(NodePtr L, datatype e)
{if (NULL == L){printf("数据类型不合法,头插失败\n");return -1;}NodePtr p = apply_node(e);if (NULL == p){printf("数据封装失败,头插失败\n");return -1;}if (list_empty(L)){p->prio = L;L->next = p;}else{p->prio = L;p->next =  L->next;L->next->prio = p; // p->next->prio =p;L->next = p;}L->len++;printf("插入成功\n");return 0;
}

6、链表遍历

// 链表遍历
int list_show(NodePtr L)
{if (NULL == L || list_empty(L)){printf("遍历失败\n");return -1;}NodePtr q = L->next; // 定义遍历指针从第一个节点出发while (q){// 输出数据域printf("%c", q->data);q = q->next; // 指针指向下一数据域}putchar(10);printf("遍历结束\n");
}

7、按完整查找

// 按位置查找
NodePtr list_search_pos(NodePtr L,datatype pos)
{if (NULL == L || list_empty(L) || pos > L->len || pos < 0){printf("查找失败\n");return NULL;}NodePtr q = L;for(int i = 0;i < pos ; i++){q = q->next;}printf("查找成功\n");return q;
}

8、按位置删除

// 按位置删除
int list_delete_pos(NodePtr L,datatype pos)
{if (NULL == L || list_empty(L) || pos < 1 || pos > L->len){printf("按位置删除失败\n");return -1;}NodePtr q = list_search_pos(L,pos);if (q->next == NULL){q->prio->next = NULL;}else{// q->next->prio = q->prio;// q->next->prio->next = q->next;q->prio->next = q->next;q->next->prio = q->prio;}L->len--;free(q);q = NULL;printf("删除成功\n");return 0;
}

9、链表删除

// 链表删除
void list_destroy(NodePtr L)
{if (NULL == L ){printf("删除失败\n");return;}while (L->next/*!(list_empty(L))*/){list_delete_pos(L,1);}if (L->next = NULL){free(L);L->next = NULL;}printf("删除成功\n");return ;
}

10、完整代码

00.h

#ifndef day16_flag_h
#define day16_flag_h
#include <myhead.h>typedef char datatype;typedef struct Node
{union {int len;datatype data;};struct Node *prio;struct Node *next;}Node,*NodePtr;NodePtr list_create();int  list_empty(NodePtr L);NodePtr apply_node(datatype e);int  list_insert_head(NodePtr l,datatype e);int list_show(NodePtr L);int list_search(NodePtr L,datatype pos);int list_delete_pos(NodePtr L,datatype e);void list_destroy(NodePtr L);#endif // day16_flag_h

00.c 

#include "00.h"
#define MAX 50// 创建链表
NodePtr list_create()
{// 在堆区申请一个头节点NodePtr L = (NodePtr)malloc(sizeof(Node));if (NULL == L){printf("创建失败\n");return NULL;}L->len = 0;L->next = NULL;L->prio = NULL;printf("链表创建成功\n");return L;
}// 判空
int list_empty(NodePtr L)
{return L->next == NULL;
}// 申请封装数据
NodePtr apply_node(datatype e)
{NodePtr p = (NodePtr)malloc(sizeof(Node));if (NULL == p){printf("数据类型不合法,封装失败\n");return NULL;}p->data = e;p->prio = NULL;p->next = NULL;return p;
}// 头插
int list_insert_head(NodePtr L, datatype e)
{if (NULL == L){printf("数据类型不合法,头插失败\n");return -1;}NodePtr p = apply_node(e);if (NULL == p){printf("数据封装失败,头插失败\n");return -1;}if (list_empty(L)){p->prio = L;L->next = p;}else{p->prio = L;p->next =  L->next;L->next->prio = p; // p->next->prio =p;L->next = p;}L->len++;printf("插入成功\n");return 0;
}// 链表遍历
int list_show(NodePtr L)
{if (NULL == L || list_empty(L)){printf("遍历失败\n");return -1;}NodePtr q = L->next; // 定义遍历指针从第一个节点出发while (q){// 输出数据域printf("%c", q->data);q = q->next; // 指针指向下一数据域}putchar(10);printf("遍历结束\n");
}// 按位置查找
NodePtr list_search_pos(NodePtr L,datatype pos)
{if (NULL == L || list_empty(L) || pos > L->len || pos < 0){printf("查找失败\n");return NULL;}NodePtr q = L;for(int i = 0;i < pos ; i++){q = q->next;}printf("查找成功\n");return q;
}// 按位置删除
int list_delete_pos(NodePtr L,datatype pos)
{if (NULL == L || list_empty(L) || pos < 1 || pos > L->len){printf("按位置删除失败\n");return -1;}NodePtr q = list_search_pos(L,pos);if (q->next == NULL){q->prio->next = NULL;}else{// q->next->prio = q->prio;// q->next->prio->next = q->next;q->prio->next = q->next;q->next->prio = q->prio;}L->len--;free(q);q = NULL;printf("删除成功\n");return 0;
}// 链表删除
void list_destroy(NodePtr L)
{if (NULL == L ){printf("删除失败\n");return;}while (L->next/*!(list_empty(L))*/){list_delete_pos(L,1);}if (L->next = NULL){free(L);L->next = NULL;}printf("删除成功\n");return ;
}

00main.c

#include "00.h"int main(int argc, char const *argv[])
{NodePtr L = list_create();if (NULL == L ){return -1;}list_insert_head(L,'H');list_show(L);list_insert_head(L,'e');list_show(L);list_insert_head(L,'l');list_show(L);list_insert_head(L,'l');list_show(L);list_insert_head(L,'o');list_show(L);list_delete_pos(L,1);list_show(L);list_delete_pos(L,2);list_show(L);list_delete_pos(L,L->len);list_show(L);list_destroy(L);list_show(L);return 0;
}

单向循环链表

1、概念

        1）循环链表，就是首尾相接的链表

        2）循环链表，就是首尾相接的链表

        3）双向循环链表:需要将最后一个阶段的指针域指向头结点，头结点的前驱指针指向最后一                 个阶段

2、循环链表的创建

        1）创建虚拟链表

// 创建链表
NodePtr list_create()
{// 在堆区申请一个头节点NodePtr L = (NodePtr)malloc(sizeof(Node));if (NULL == L){printf("创建失败\n");return NULL;}L->len = 0;L->next = NULL;L->prio = NULL;printf("链表创建成功\n");return L;
}

        2）判空

// 判空
int list_empty(NodePtr L)
{return L->next == L;
}

        3）申请封装数据

// 申请封装数据
NodePtr apply_node(datatype e)
{NodePtr p = (NodePtr)malloc(sizeof(Node));if (NULL == p){printf("数据类型不合法,封装失败\n");return NULL;}p->data = e;p->next = NULL;return p;
}

        4）按位置查找

// 按位置查找
NodePtr list_search_pos(NodePtr L, datatype pos)
{if (NULL == L || list_empty(L) || pos > L->len || pos < 0){printf("查找失败\n");return NULL;}NodePtr q = L;for (int i = 0; i < pos; i++){q = q->next;}printf("查找成功\n");return q;
}

        5）头插

// 头插
int list_insert_head(NodePtr L, datatype e)
{// 判断逻辑if (NULL == L){printf("插入失败\n");return -1;}NodePtr p = apply_node(e);if (NULL == p){printf("封装失败\n");return -1;}p->next = L->next;L->next = p;L->len++;printf("插入成功\n");return 0;
}

        6）尾插

// 尾插
int list_insert_tail(NodePtr L, datatype e)
{// 判断逻辑if (NULL == L){printf("尾插插入失败\n");return -1;}// 找到最后一个节点NodePtr q = list_search_pos(L, L->len);// 封装节点NodePtr p = apply_node(e);// 插入逻辑p->next = q->next;q->next = p;L->len++;printf("尾插插入成功\n");return 0;
}

        7）头删

//头删
int list_delete_head(NodePtr L)
{if (NULL == L || list_empty(L)){printf("头删失败\n");return -1;}NodePtr p = L->next;L->next = p->next;free(p);p = NULL;L->len--;printf("头删成功\n");return 0;
}

        8）链表删除

// 链表删除
void list_destroy(NodePtr L)
{if (NULL == L ){printf("删除失败\n");return;}while (L->next == L){list_delete_head(L);}free(L);L = NULL;printf("删除成功\n");return ;
}

        9）完整代码

00.h

#ifndef day16_1_flag_h
#define day16_1_flag_h
#include <myhead.h>typedef char datatype;typedef struct Node
{union {int len;datatype data;};struct Node *next;}Node,*NodePtr;NodePtr list_create();int  list_empty(NodePtr L);NodePtr apply_node(datatype e);NodePtr list_search_pos(NodePtr L,datatype pos);int list_insert_tail(NodePtr L,datatype e);int list_insert_head(NodePtr L,datatype e);int list_show(NodePtr L);int list_delete_head(NodePtr L);void list_destroy(NodePtr L);#endif // day16_1_flag_h

00.c

#include "00.h"
#define MAX 50// 创建链表
NodePtr list_create()
{// 在堆区申请一个头节点NodePtr L = (NodePtr)malloc(sizeof(Node));if (NULL == L){printf("创建失败\n");return NULL;}L->len = 0;L->next = L; // 头节点指针域指向自己printf("链表创建成功\n");return L;
}// 判空
int list_empty(NodePtr L)
{return L->next == L;
}// 申请封装数据
NodePtr apply_node(datatype e)
{NodePtr p = (NodePtr)malloc(sizeof(Node));if (NULL == p){printf("数据类型不合法,封装失败\n");return NULL;}p->data = e;p->next = NULL;return p;
}// 按位置查找
NodePtr list_search_pos(NodePtr L, datatype pos)
{if (NULL == L || list_empty(L) || pos > L->len || pos < 0){printf("查找失败\n");return NULL;}NodePtr q = L;for (int i = 0; i < pos; i++){q = q->next;}printf("查找成功\n");return q;
}// 头插
int list_insert_head(NodePtr L, datatype e)
{// 判断逻辑if (NULL == L){printf("插入失败\n");return -1;}NodePtr p = apply_node(e);if (NULL == p){printf("封装失败\n");return -1;}p->next = L->next;L->next = p;L->len++;printf("插入成功\n");return 0;
}// 尾插
int list_insert_tail(NodePtr L, datatype e)
{// 判断逻辑if (NULL == L){printf("尾插插入失败\n");return -1;}// 找到最后一个节点NodePtr q = list_search_pos(L, L->len);// 封装节点NodePtr p = apply_node(e);// 插入逻辑p->next = q->next;q->next = p;L->len++;printf("尾插插入成功\n");return 0;
}//链表遍历
int list_show(NodePtr L)
{if (NULL == L || list_empty(L)){printf("遍历失败\n");return -1;}NodePtr q = L->next;while(q !=L){printf("%c",q->data);q = q->next;}putchar(10);printf("遍历成功\n");return 0;
}//头删
int list_delete_head(NodePtr L)
{if (NULL == L || list_empty(L)){printf("头删失败\n");return -1;}NodePtr p = L->next;L->next = p->next;free(p);p = NULL;L->len--;printf("头删成功\n");return 0;
}// 链表删除
void list_destroy(NodePtr L)
{if (NULL == L ){printf("删除失败\n");return;}while (L->next == L){list_delete_head(L);}free(L);L = NULL;printf("删除成功\n");return ;
}

00main.c

#include "00.h"int main(int argc, char const *argv[])
{NodePtr L = list_create();if (NULL == L ){return -1;}list_insert_head(L,'H');list_show(L);list_insert_head(L,'e');list_show(L);list_insert_head(L,'l');list_show(L);list_insert_head(L,'l');list_show(L);list_insert_head(L,'o');list_show(L);list_insert_tail(L,'Z');list_show(L);list_delete_head(L);list_show(L);list_destroy(L);list_show(L);return 0;
}

        10)约瑟夫环问题

00.h

#ifndef day16_1_flag_h
#define day16_1_flag_h
#include <myhead.h>typedef int datatype;typedef struct Node
{union {int len;datatype data;};struct Node *next;}Node,*NodePtr;NodePtr list_create();int  list_empty(NodePtr L);NodePtr apply_node(datatype e);NodePtr list_search_pos(NodePtr L,datatype pos);int list_insert_tail(NodePtr L,datatype e);int list_insert_head(NodePtr L,datatype e);int list_show(NodePtr L);int list_delete_head(NodePtr L);void list_destroy(NodePtr L);// 任意位置删除
int list_delete_pos(NodePtr L, int pos);//按位置取值
int list_pos_value(NodePtr L,int pos);
#endif // day16_1_flag_h

00.c

#include "00.h"
#define MAX 50// 创建链表
NodePtr list_create()
{// 在堆区申请一个头节点NodePtr L = (NodePtr)malloc(sizeof(Node));if (NULL == L){printf("创建失败\n");return NULL;}L->len = 0;L->next = L; // 头节点指针域指向自己printf("链表创建成功\n");return L;
}// 判空
int list_empty(NodePtr L)
{return L->next == L;
}// 申请封装数据
NodePtr apply_node(datatype e)
{NodePtr p = (NodePtr)malloc(sizeof(Node));if (NULL == p){printf("数据类型不合法,封装失败\n");return NULL;}p->data = e;p->next = NULL;return p;
}// 按位置查找
NodePtr list_search_pos(NodePtr L, datatype pos)
{if (NULL == L || list_empty(L) || pos > L->len || pos < 0){printf("查找失败\n");return NULL;}NodePtr q = L;for (int i = 0; i < pos; i++){q = q->next;}printf("查找成功\n");return q;
}// 头插
int list_insert_head(NodePtr L, datatype e)
{// 判断逻辑if (NULL == L){printf("插入失败\n");return -1;}NodePtr p = apply_node(e);if (NULL == p){printf("封装失败\n");return -1;}p->next = L->next;L->next = p;L->len++;printf("插入成功\n");return 0;
}// 尾插
int list_insert_tail(NodePtr L, datatype e)
{// 判断逻辑if (NULL == L){printf("尾插插入失败\n");return -1;}// 找到最后一个节点NodePtr q = list_search_pos(L, L->len);// 封装节点NodePtr p = apply_node(e);// 插入逻辑p->next = q->next;q->next = p;L->len++;printf("尾插插入成功\n");return 0;
}//链表遍历
int list_show(NodePtr L)
{if (NULL == L || list_empty(L)){printf("遍历失败\n");return -1;}NodePtr q = L->next;while(q !=L){printf("%d\t",q->data);q = q->next;}putchar(10);printf("遍历成功\n");return 0;
}//头删
int list_delete_head(NodePtr L)
{if (NULL == L || list_empty(L)){printf("头删失败\n");return -1;}NodePtr p = L->next;L->next = p->next;free(p);p = NULL;L->len--;printf("头删成功\n");return 0;
}// 链表删除
void list_destroy(NodePtr L)
{if (NULL == L ){printf("删除失败\n");return;}while (L->next == L){list_delete_head(L);}free(L);L = NULL;printf("删除成功\n");return ;
}// 任意位置删除
int list_delete_pos(NodePtr L, int pos)
{if (NULL == L || pos > L->len + 1 || pos < 1){printf("删除失败\n");return -1;}NodePtr q = list_search_pos(L, pos - 1);NodePtr p = q->next;q->next = p->next;free(p);p = NULL;L->len--;printf("删除成功\n");return 0;
}

 00main.c

#include "00.h"int main(int argc, char const *argv[])
{//创建列表NodePtr L = list_create();if (NULL == L){return -1;}//num 人数  die 死亡序号int num, die = 0;printf("输入参与约瑟夫游戏的人数:\n");scanf("%d", &num);printf("报数到多少被杀掉:\n");scanf("%d", &die);//为参与者赋予代号for (int i = 0; i < num; i++){list_insert_head(L, i+1);}list_show(L);//day 日期   all 总人数   death 死者数组int day = 0;int all = num;datatype death[100] = {0};  //死者序列NodePtr p = L;while (num>all/2){for (int i = 0; i < die-1; i++){if (p->next == L)//到头节点时多偏移一位，略过头节点{p = p->next;}p = p->next;}int kill = p->next->data;           //死者代号death[day] = kill;                  //将死者代号存入死者名列printf("%d\n",kill);list_delete_head(p->next);          //删除死者位置day++;                              //日期推移num--;                              //人数减一}printf("死者代号及顺序依次为:\n");for (int i = 0; i < day; i++){printf("%d\t", death[i]);}putchar(10);return 0;
}

双向循环链表

00.h

#ifndef day16_1_flag_h
#define day16_1_flag_h
#include <myhead.h>typedef char datatype;typedef struct Node
{union {int len;datatype data;};struct Node *next;struct Node *prio;}Node,*NodePtr;NodePtr list_create();int  list_empty(NodePtr L);NodePtr apply_node(datatype e);NodePtr list_search_pos(NodePtr L,datatype pos);int list_insert_tail(NodePtr L,datatype e);int list_insert_head(NodePtr L,datatype e);int list_show(NodePtr L);int list_delete_head(NodePtr L);void list_destroy(NodePtr L);// 任意位置删除
int list_delete_pos(NodePtr L, int pos);//按位置取值
int list_pos_value(NodePtr L,int pos);//按位置修改
int list_change_pos(NodePtr L,int pos,datatype e);
#endif // day16_1_flag_h

00.c

#include "00.h"
#define MAX 50// 创建链表
NodePtr list_create()
{// 在堆区申请一个头节点NodePtr L = (NodePtr)malloc(sizeof(Node));if (NULL == L){printf("创建失败\n");return NULL;}L->len = 0;L->next = L; // 头节点指针域指向自己L->prio = L;printf("链表创建成功\n");return L;
}// 判空
int list_empty(NodePtr L)
{return L->next == L;
}// 申请封装数据
NodePtr apply_node(datatype e)
{NodePtr p = (NodePtr)malloc(sizeof(Node));if (NULL == p){printf("数据类型不合法,封装失败\n");return NULL;}p->data = e;p->next = NULL;p->prio = NULL;return p;
}// 按位置查找
NodePtr list_search_pos(NodePtr L, datatype pos)
{if (NULL == L || list_empty(L) || pos > L->len || pos < 0){printf("查找失败\n");return NULL;}NodePtr q = L;for (int i = 0; i < pos; i++){q = q->next;}printf("查找成功\n");return q;
}// 头插
int list_insert_head(NodePtr L, datatype e)
{if (NULL == L){printf("数据类型不合法,头插失败\n");return -1;}NodePtr p = apply_node(e);if (NULL == p){printf("数据封装失败,头插失败\n");return -1;}if (list_empty(L)){p->prio = L;p->next = L->next; // p->next = LL->next = p;L->prio = p;}else{p->prio = L;p->next = L->next;L->next->prio = p; // p->next->prio =p;L->next = p;}L->len++;printf("插入成功\n");return 0;
}// 尾插
int list_insert_tail(NodePtr L, datatype e)
{// 判断逻辑if (NULL == L){printf("尾插插入失败\n");return -1;}// 找到最后一个节点NodePtr q = list_search_pos(L, L->len);// 封装节点NodePtr p = apply_node(e);// 插入逻辑p->next = q->next;p->prio = q;q->next = p;L->len++;printf("尾插插入成功\n");return 0;
}// 链表遍历
int list_show(NodePtr L)
{if (NULL == L || list_empty(L)){printf("遍历失败\n");return -1;}NodePtr q = L->next;while (q != L){printf("%c", q->data);q = q->next;}putchar(10);printf("遍历成功\n");return 0;
}// 头删
int list_delete_head(NodePtr L)
{if (NULL == L || list_empty(L)){printf("头删失败\n");return -1;}NodePtr p = L->next;L->next = p->next;p->next->prio = L;free(p);p = NULL;L->len--;printf("头删成功\n");return 0;
}// 链表删除
void list_destroy(NodePtr L)
{if (NULL == L){printf("删除失败\n");return;}while (L->next == L){list_delete_head(L);}free(L);L = NULL;printf("删除成功\n");return;
}// 任意位置删除
int list_delete_pos(NodePtr L, int pos)
{if (NULL == L || pos > L->len + 1 || pos < 1){printf("删除失败\n");return -1;}NodePtr q = list_search_pos(L, pos - 1);NodePtr p = q->next;q->next = p->next;p->next->prio = q;free(p);p = NULL;// NodePtr p = L->next;// L->next = p->next;// p->next->prio = L;// free(p);// p = NULL;L->len--;printf("按位置删除成功\n");return 0;
}//按位置修改
int list_change_pos(NodePtr L,int pos,datatype e)
{if (NULL == L || pos > L->len + 1 || pos < 1){printf("修改失败\n");return -1;}NodePtr q = list_search_pos(L, pos);q->data = e;printf("按位置修改成功\n");return 0;
}
#include "00.h"int main(int argc, char const *argv[])
{NodePtr L = list_create();if (NULL == L ){return -1;}putchar(10);list_insert_head(L,'H');list_insert_head(L,'e');list_insert_head(L,'l');list_insert_head(L,'l');list_insert_head(L,'o');list_show(L);putchar(10);list_insert_tail(L,'Z');list_show(L);putchar(10);list_delete_head(L);list_show(L);putchar(10);list_delete_pos(L,3);list_show(L);putchar(10);list_change_pos(L,4,'A');list_show(L);putchar(10);list_destroy(L);list_show(L);putchar(10);return 0;
}

实现结果

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

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

72 | 数据分析岗位招聘数据可视化

72 | 数据分析岗位招聘数据可视化

项目介绍 本项目旨在通过对智联招聘网站上发布的数据分析岗位信息的分析和可视化，帮助应届毕业生和希望进入数据分析行业的专业人士更好地理解当前的就业市场。通过收集包含职位名称、薪资范围、地点、工作经验、学历要求等关键信息的数据，项目深入探讨了数据分析岗位的多个…
阅读更多...
【大师与bug里特】M_Studio《王国之梦》学习笔记

【大师与bug里特】M_Studio《王国之梦》学习笔记

1️⃣ Object & object(✅) 之辨 《7.泛型事件框架〈余2min左右时〉》 不然inspector窗口的最后一行&#xff08;告诉我们订阅者是SceneLoadManager它身上挂了☝️ObjectEventListener用来监听这个事件 有多少个事件注册到这里来了都能够看到&#xff09;还是不会出现 加上…
阅读更多...
【JVM基础05】——组成-能不能解释一下方法区？

【JVM基础05】——组成-能不能解释一下方法区？

目录 1- 引言&#xff1a;方法区概述1-1 方法区是什么&#xff1f;(What)1-2 为什么用方法区&#xff1f;方法区的作用 (Why) 2- ⭐核心&#xff1a;详解方法区(How)2-1 能不能解释一下方法区&#xff1f;2-2 元空间内存溢出问题2-3 什么是常量池&#xff1f;2-4 运行时常量池 …
阅读更多...
接口自动化测试框架实战-2-项目接口文档

接口自动化测试框架实战-2-项目接口文档

上一小节我们完成了项目开发环境的搭建&#xff0c;本小结我们具体介绍一下项目中使用到的接口文档。 本次我们以钉钉开放接口作为项目接口测试的示例&#xff0c;方便大家都能统一学习和调用&#xff0c;具体接口如下&#xff1a; 1、获取企业内部应用的access_token 在获取…
阅读更多...
软件测试---测试需求分析

软件测试---测试需求分析

课程目标 什么是软件测试需求 软件测试需求的必要性 如何对软件测试需求进行分析&#xff08;重点&#xff09; 课程补充 灰度测试&#xff08;基于功能&#xff09;&#xff1a;先发布部分功能&#xff0c;然后看用户的反馈&#xff0c;再去发布另外一部分的功能更新。 A/B测…
阅读更多...
Domainim：一款高效的企业级网络安全扫描工具

Domainim：一款高效的企业级网络安全扫描工具

关于Domainim Domainim是一款功能强大的企业级网络安全扫描工具&#xff0c;该工具运行效率高&#xff0c;功能完善&#xff0c;可以帮助广大研究人员针对企业或组织网络执行大规模安全扫描任务。 该工具可以快速执行网络安全扫描和域名/子域名网络侦查任务&#xff0c;旨在使…
阅读更多...
Llama 3.1要来啦？！测试性能战胜GPT-4o

Llama 3.1要来啦？！测试性能战胜GPT-4o

哎呀&#xff0c;Meta声称将于今晚发布的Llama 3.1&#xff0c;数小时前就在Hugging Face上泄露出来了&#xff1f;泄露的人很有可能是Meta员工&#xff1f; 还是先来看泄露出来的llama3.1吧。新的Llama 3.1模型包括8B、70B、405B三个版本。 而经过网友测试&#xff0c;该base…
阅读更多...
Elasticsearch-RestAPI --学习笔记

Elasticsearch-RestAPI --学习笔记

RestAPI ES官方提供了各种不同语言的客户端&#xff0c;用来操作ES。这些客户端的本质就是组装DSL语句&#xff0c;通过http请求发送给ES。 官方文档地址&#xff1a; Elasticsearch Clients | Elastic 以下关于RestAPI 的说明都是基于老版本客户端 初始化RestClient 1&…
阅读更多...
STM32CUBEIDE FreeRTOS操作教程（一）：LED闪灯

STM32CUBEIDE FreeRTOS操作教程（一）：LED闪灯

STM32CUBEIDE FreeRTOS操作教程&#xff08;一&#xff09;&#xff1a;LED闪灯 STM32CUBEIDE(不是STM32CUBEMX)开发环境集成了STM32 HAL库进行FreeRTOS配置和开发的组件&#xff0c;不需要用户自己进行FreeRTOS的移植。这里介绍最简化的用户操作类应用教程。以STM32F401RCT6开…
阅读更多...
防御课第2次作业

防御课第2次作业

实验拓扑图 实验目的 7&#xff0c;办公区设备可以通过电信链路和移动链路上网(多对多的NAT&#xff0c;并且需要保留一个公网IP不能用来转换) 8&#xff0c;分公司设备可以通过总公司的移动链路和电信链路访问到Dmz区的http服务器 9&#xff0c;多出口环境基于带宽比例进行选…
阅读更多...
内网隧道——HTTP隧道

内网隧道——HTTP隧道

文章目录 一、ReGeorg二、Neo-reGeorg三、Pivotnacci 实验网络拓扑如下&#xff1a; 攻击机kali IP&#xff1a;192.168.111.0 跳板机win7 IP&#xff1a;192.168.111.128&#xff0c;192.168.52.143 靶机win server 2008 IP&#xff1a;192.168.52.138 攻击机与Web服务器彼此之…
阅读更多...
Leetcode3216. 交换后字典序最小的字符串

Leetcode3216. 交换后字典序最小的字符串

Every day a Leetcode 题目来源&#xff1a;3216. 交换后字典序最小的字符串 解法1&#xff1a;模拟 找到第一个 s[i] > s[i 1]&#xff0c;且它们奇偶性相同&#xff0c;交换它们。 代码&#xff1a; /** lc appleetcode.cn id3216 langcpp** [3216] 交换后字典序最小…
阅读更多...
elk日志索引被锁blocks，日志无法写入

elk日志索引被锁blocks，日志无法写入

现象&#xff1a; kafka积压&#xff0c;logstash无法将日志写入到es logstash报错&#xff1a; [logstash.outputs.elasticsearch][main][] Retrying failed action {:status>403 :error>{“type”>“cluster_block_exception”, “reason”>“index [] blocked …
阅读更多...
鸿蒙OpenHarmony Native API【drawing_path.h】 头文件

鸿蒙OpenHarmony Native API【drawing_path.h】 头文件

drawing_path.h Overview Related Modules: [Drawing] Description: 文件中定义了与自定义路径相关的功能函数 Since: 8 Version: 1.0 Summary Functions FunctionDescription[OH_Drawing_PathCreate] (void)[OH_Drawing_Path] * 函数用于创建一个路径对象OH_Drawin…
阅读更多...
怎么查快递和物流到哪里了，快递丢失怎么处理？

怎么查快递和物流到哪里了，快递丢失怎么处理？

随着电子商务的发展&#xff0c;物流也越来越发达&#xff0c;人们的生活中有很多地方都与物流快递打交道。网购或者给远方的亲戚朋友寄礼物等等都需要快递。有时候想要知道快递寄送请款就要查询快递单号&#xff0c;那么&#xff0c;快递单号查询方法有哪些&#xff1f;没有快…
阅读更多...
Django视图与URLs路由详解

Django视图与URLs路由详解

在Django Web框架中&#xff0c;视图&#xff08;Views&#xff09;和URLs路由&#xff08;URL routing&#xff09;是Web应用开发的核心概念。它们共同负责将用户的请求映射到相应的Python函数&#xff0c;并返回适当的响应。本篇博客将深入探讨Django的视图和URLs路由系统&am…
阅读更多...
搞一个boostrap主题，用django的mtv去对接

搞一个boostrap主题，用django的mtv去对接

nginx的配置,设定这个模板映射的路径 location /assets/{alias /home/luichun/lc/Pyfile/Pyhome/app/statichome_to_nginx/pifu/dist/assets/;}1&#xff1a;设定一个主页的路由【django主要用来设定逻辑】 2&#xff1a;设定主页的响应内容【使用boostrap框架来对前端展示进行…
阅读更多...
《梦醒蝶飞：释放Excel函数与公式的力量》18.2 数据可视化技术

《梦醒蝶飞：释放Excel函数与公式的力量》18.2 数据可视化技术

第18章&#xff1a;创建图表和数据可视化 18.2 数据可视化技术 数据可视化是将数据转化为图形和图表的过程&#xff0c;以便更好地理解和分析数据。有效的数据可视化可以揭示数据的模式、趋势和异常&#xff0c;从而帮助做出更明智的决策。以下将介绍几种常用的数据可视化技术…
阅读更多...
WiFi通信——STM32通过ESP8266-01S与阿里云通信

WiFi通信——STM32通过ESP8266-01S与阿里云通信

嵌入式设计中常用的无线通信方式主要由蓝牙、WiFi、Zigbee、Lora、NB-IOT等等。这些是最常用的&#xff0c;也是在实际项目开发中根据项目的数据通信特点来选择相应的无线通信方式。本设计主要是讲解WiFi在嵌入式开发中的使用。 1. ESP8266-01S烧录固件 WiFi通信的频段和蓝牙一…
阅读更多...
vue3前端开发-小兔鲜项目-图片切换效果和动态class

vue3前端开发-小兔鲜项目-图片切换效果和动态class

vue3前端开发-小兔鲜项目-图片切换效果和动态class!这次实现的效果是&#xff0c;图片预览效果&#xff0c;根据小图片&#xff0c;来实时改变大图&#xff08;预览&#xff09;的效果。同时让动态的特征class也跟着显示出来。 <script setup> import {ref} from vue // …
阅读更多...
最新文章

Copyright @ 2022~2023