学习记录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.mzph.cn/diannao/49471.shtml

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

相关文章

[论文笔记] DCA（Dual Chunk Attention）

[论文笔记] DCA（Dual Chunk Attention）

DCA&#xff08;Dual Chunk Attention&#xff09;是一种在自然语言处理模型中用来处理长文本的技术。传统的注意力机制&#xff08;Attention&#xff09;在处理长文本时可能会遇到效率和性能瓶颈&#xff0c;因为计算每个单词与其他所有单词之间的关系会随着文本长度的增加而…
阅读更多...
Nova Admin - 简洁干净、免费开源的后台管理系统，基于Vue3 / Vite5 / Typescript / Naive UI 等前端开发技术栈

Nova Admin - 简洁干净、免费开源的后台管理系统，基于Vue3 / Vite5 / Typescript / Naive UI 等前端开发技术栈

今天看到一款 Vue3 后台管理 admin 系统&#xff0c;研究了一下发现很不错&#xff0c;推荐给大家。 Nova-admin 是一个颜值在线&#xff0c;风格清新、简洁干净后台管理模板&#xff0c;包含了平时常用的管理后台功能页面模板。基础的 UI 组件基于我之前推荐的 naive-ui 开发…
阅读更多...
【Golang 面试基础题】每日 5 题（六）

【Golang 面试基础题】每日 5 题（六）

✍个人博客&#xff1a;Pandaconda-CSDN博客 &#x1f4e3;专栏地址&#xff1a;http://t.csdnimg.cn/UWz06 &#x1f4da;专栏简介&#xff1a;在这个专栏中&#xff0c;我将会分享 Golang 面试中常见的面试题给大家~ ❤️如果有收获的话&#xff0c;欢迎点赞&#x1f44d;收藏…
阅读更多...
HTML前端 盒模型及常见的布局 流式布局 弹性布局 网格布局

HTML前端 盒模型及常见的布局 流式布局 弹性布局 网格布局

CSDN的文章没有“树状目录管理”&#xff0c;所以我在这里整理几篇相关的博客链接。 操作有些麻烦。 CSS 两种盒模型 box-sizing content-box 和 border-box 流式布局 flow layout 弹性布局 flex layout HTML CSS 网格布局 grid layout HTML CSS
阅读更多...
百度,有道,谷歌翻译API

百度,有道,谷歌翻译API

API翻译 百度&#xff0c;有道&#xff0c;谷歌API翻译&#xff08;只针对中英相互翻译&#xff09;,其他语言翻译需要对应from&#xff0c;to的code 百度翻译 package fills.tools.translate; import java.util.ArrayList; import java.util.HashMap; import java.util.Lis…
阅读更多...
Win11+Anaconda+VScode：mmpose环境配置与基本使用

Win11+Anaconda+VScode：mmpose环境配置与基本使用

MMPose 是一款基于 PyTorch 的姿态分析的开源工具箱，是 OpenMMLab 项目的成员之一。 目录 前言 一、mmpose整体框架 二、依赖与安装 从源码安装（推荐） 作为 Python 包安装 三、验证安装 四、使用mmpose处理数据 总结 前言 官方安装手册：欢迎来到 MMPose 中文文档!…
阅读更多...
TMS320F28335多级中断及中断响应过程

TMS320F28335多级中断及中断响应过程

DSP28335的中断系统设计为多级中断机制&#xff0c;主要包括外设级中断、PIE级中断和CPU级中断。以下是详细的中断使能及响应过程&#xff1a; 1.外设级中断&#xff1a; 当外设产生中断事件时&#xff0c;对应的中断标志寄存器&#xff08;IF&#xff09;的相应位将被自动置…
阅读更多...
ABAP+从SAP发出去的PDF文件在第三方系统出现乱码

ABAP+从SAP发出去的PDF文件在第三方系统出现乱码

这是一个 ABAP转换PDF调用函数CALL FUNCTION CONVERT_OTF的问题记录&#xff0c;关乎字体STSong-Light-ldentity-H 和 STSong-Light的区别 背景&#xff1a; 做了一个增强&#xff0c;是采购订单审批后自动发送采购订单PDF1到企业微信&#xff0c;用户再将企业微信收到的P…
阅读更多...
C# 代理模式

C# 代理模式

栏目总目录 概念 代理模式是一种结构型设计模式&#xff0c;它为其他对象提供一种代理以控制对这个对象的访问。在代理模式中&#xff0c;我们创建一个具有现有对象&#xff08;称为“真实对象”或“被代理对象”&#xff09;相同功能的代理对象。代理对象可以在客户端和目标对…
阅读更多...
【海康威视】-Java读取监控摄像头实时帧

【海康威视】-Java读取监控摄像头实时帧

目录 1、基于JavaCV 1.1、pom依赖 1.2、读取帧Frame 1.3、转换BufferedImage 1.4、完整代码 2、基于Ffmpeg命令 2.1、ffmpeg命令 2.2、读取帧 2.3、转换BufferedImage 2.4、完整代码 1、基于JavaCV 1.1、pom依赖 <dependency><groupId>org.bytedeco<…
阅读更多...
最优化理论与方法-第十讲割平面法

最优化理论与方法-第十讲割平面法

文章目录 1. 原问题&#xff1a;2. 割平面法程序步骤2.1 第一次迭代2.2 第二次迭代2.3 第三次迭代 1. 原问题&#xff1a; 给定下列约束优化问题&#xff1a; ( P ) min ⁡ 3 x 1 2 2 x 2 2 s t . − 5 x 1 − 2 x 2 3 ≤ 0 , x ∈ X { x ∈ Z n ∣ 8 x 1 8 x 2 ≥ 1 , 0…
阅读更多...
mysql的主从复制和读写分离：

mysql的主从复制和读写分离：

mysql的主从复制和读写分离&#xff1a; 主从复制 面试必问&#xff1a;主从复制的原理 主从复制的模式&#xff1a; 1、mysql的默认模式&#xff1a; 异步模式 主库在更新完事务之后会立即把结果返回给从服务器&#xff0c;并不关心从库是否接受到&#xff0c;以及从库是…
阅读更多...
共享存储可以解决FusionCompute哪些问题

共享存储可以解决FusionCompute哪些问题

共享存储在FusionCompute环境中扮演着至关重要的角色&#xff0c;主要通过提供集中的数据访问点来优化和增强虚拟化基础设施的功能。以下是共享存储在FusionCompute中可以解决的一些关键问题&#xff1a; 虚拟机迁移&#xff1a; 共享存储允许虚拟机&#xff08;VM&#xff09;…
阅读更多...
【React】package.json 文件详解

【React】package.json 文件详解

文章目录 一、package.json 文件的基本结构二、package.json 文件的关键字段1. name 和 version2. description3. main4. scripts5. dependencies 和 devDependencies6. repository7. keywords8. author 和 license9. bugs 和 homepage 三、package.json 文件的高级配置1. 配置…
阅读更多...
分享一个Springer模板关于论文作者和单位信息的修改范例，以及Applied Intelligence期刊latex模板的下载链接

分享一个Springer模板关于论文作者和单位信息的修改范例，以及Applied Intelligence期刊latex模板的下载链接

在这篇文章中&#xff0c;我写一些关于解决springer期刊提供的LaTex模板参考文献格式为作者年份时的顺序问题以及如何在正文中将参考文献格式引用成[1]这种数字格式类似的经验&#xff0c;该篇帖子里还分享了一个大佬关于springer模板完整的修改流程&#xff0c;有需要的伙伴可…
阅读更多...
全球电脑蓝屏崩溃，为何中国没事？周鸿祎：因 90% 用 360 软件！

全球电脑蓝屏崩溃，为何中国没事？周鸿祎：因 90% 用 360 软件！

2024 年 7 月 19 日&#xff0c;出现了震惊世界的微软蓝屏事件&#xff0c;全球近千万台 Windows 设备集体蓝屏宕机&#xff01; 这次的事件绝对称得上是 “载入史册”&#xff01;甚至百度百科都专门针对这次的事件出了一个词条、央视新闻也专门报道了此事。 这次事件的影响有…
阅读更多...
ActiViz实战：二维纹理贴图vtkTexture

ActiViz实战：二维纹理贴图vtkTexture

文章目录 一、效果预览二、基本概念三、功能特性四、与C++不同五、完整示例代码一、效果预览 二、基本概念 vtkTexture是VTK（Visualization Toolkit）中用于纹理映射的一个类，它允许用户将二维图像（纹理）贴到三维物体的表面上，从而增加场景的真实感和细节。 纹理映射：是一…
阅读更多...
PY32F071单片机，主频最高72兆，资源丰富，有USB,DAC,运放

PY32F071单片机，主频最高72兆，资源丰富，有USB,DAC,运放

PY32F071 系列单片机是基于32 位 ARM Cortex-M0 内核的微控制器&#xff0c;宽电压工作范围的 MCU。芯片嵌入高达 128 Kbytes flash 和 16 Kbytes SRAM 存储器&#xff0c;最高72 MHz工作频率。芯片支持串行调试 (SWD)。PY32F071单片机提供了包含了HAL和LL两种不同层次的驱动库…
阅读更多...
自定义webIpad证件相机(webRTC)

自定义webIpad证件相机(webRTC)

该技术方案可用于各浏览器自定义相机开发 相机UI&#xff08;index.html&#xff09; <!DOCTYPE html> <html lang"zh" prew"-1"><head><meta charset"UTF-8"><meta name"viewport"content"user-sc…
阅读更多...
Redis从入门到超神-(六)SpringCache操作缓存

Redis从入门到超神-(六)SpringCache操作缓存

引言 java操作Redis有很多中方案&#xff0c;Jedis&#xff0c;SpringBootDataRedis,Redisson等&#xff0c;本篇文章的目的是使用SpringBootDataRedis整合SpringCache基于Redis实现缓存操作 一、SpringBoot整合Redis实现缓存 SpringBoot提供了整合Redis的方案&#xff0c;我…
阅读更多...
最新文章

Copyright @ 2022~2023