第2章 双向链表

双向链表

概念

对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可大大增加链表操作的便捷性。因 此，双向循环链表，是在实际运用中是最常见的链表形态。

基本操作

与普通的链表完全一致，双向循环链表虽然指针较多，但逻辑是完全一样。

基本的操作包括：

1. 节点设计

2. 初始化空链表

3. 增删节点

4. 链表遍历

5. 销毁链表

节点设计

双向链表的节点只是比单向链表多了一个前向指针。示例代码如下所示：

typedef int DATA;
typedef struct node
{
// 以整型数据为例
DATA data;
// 指向相邻的节点的双向指针
struct node *prev;
struct node *next;
}NODE;

初始化

所谓初始化，就是构建一条不含有效节点的空链表。 以带头结点的双向循环链表为例，初始化后，其状态如下图所示：

在初始空链表的情况下，链表只有一个头结点，下面是初始化示例代码：

int dlist_create(NODE** head,DATA data)
{
// 创建新节点（申请内存空间）
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
// 给节点赋初值
pNew -> data = data;
// 前后指针默认都指向NULL
pNew -> prev = pNew -> next = NULL;
// 将新节点作为头节点
*head = pNew;
return 0;
}

插入节点

与单链表类似，也可以对双链表中的任意节点进行增删操作，常见的有所谓的头插法、尾插法等， 即：将新节点插入到链表的首部或者尾部，示例代码是：

头插法：将新节点插入到链表的头部

// 将新节点pNew，插入到链表的首部
int dlist_addHead(NODE** head,DATA data)
{
// 创建新节点并申请内存
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
// 给新节点赋值
pNew -> data = data;
pNew -> prev = NULL;
// 后针指向头指针
pNew -> next = *head;
// 如果头指针存在
if(*head)
// 头指针的前指针指向新节点
(*head) -> prev = pNew;
// 新插入的节点作为新的头节点
*head = pNew;
return 0;
}
// 将新节点pNew，插入到链表的尾部
int dlist_addTail(NODE** head,DATA data)
{
// 创建节点并申请内存
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
// 初始化节点
pNew -> data = data;
pNew -> prev = NULL;
pNew -> next = NULL;
// 用来记录尾节点，默认头节点就是尾节点
NODE* p = *head;
if(!p)
{
// 头节点不存在，新插入的节点作为头节点
*head = pNew;
return 0;
}
// 通过循环，查找尾节点
while(p -> next)
{
p = p -> next;
}
// 尾节点的后指针指向新插入的节点
p -> next = pNew;
// 新插入的节点的前指针指向尾节点
pNew -> prev = p;
// 此时的新节点作为了新的尾节点
return 0;
}

中间插法：将新节点插入到链表的指定位置

// 将新节点pNew，插入到链表的指定位置
int dlist_insert(NODE** head,DATA pos,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> prev = NULL;
pNew -> next = NULL;
NODE* p = *head, *q = NULL;
if(!p)
{
*head = pNew;
return 0;
}
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = p;
p -> prev = pNew;
*head = pNew;
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = p;
pNew -> prev = q;
p -> prev = pNew;
q -> next = pNew;
return 0;
}
q = p;
p = p -> next;
}
q -> next = pNew;
pNew -> prev = q;
return 0;

剔除节点

注意，从链表中将一个节点剔除出去，并不意味着要释放节点的内容。当然，我们经常在剔除了一个 节点之后，紧接着的动作往往是释放它，但是将“剔除”与“释放”两个动作分开，是最基本的函数封装的 原则，因为它们虽然常常连在一起使用，但它们之间并无必然联系，例如：当我们要移动一个节点的 时候，实质上就是将“剔除”和“插入”的动作连起来，此时就不能释放该节点了。

在双向链表中剔除指定节点的示例代码如下：

// 将data对应的节点从链表中剔除
int dlist_delete(NODE** head,DATA data)
{
NODE* p = *head;
if(!p)
return -1;
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
if(p -> next == NULL)
{
*head = NULL;
free(p);
return 0;
}
*head = p -> next;
p -> next -> prev = NULL;
free(p);
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
p -> prev -> next = p -> next;
if(p -> next == NULL)
p -> prev -> next = NULL;
else
p -> next -> prev = p -> prev;
free(p) ;
return 0;
}
p = p -> next;
}
return -1;
}

链表的遍历

对于双向循环链表，路径可以是向后遍历，也可以向前遍历。

下面是根据指定数据查找节点，向前、向后遍历的示例代码，假设遍历每个节点并将其整数数据输 出：

// 根据指定数据查找节点
NODE* dlist_find(const NODE* head,DATA data)
{
const NODE* p = head;
while(p)
{
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
return (NODE*)p;
p = p -> next;
}
return NULL;
}
// 向前|向后遍历
void dlist_showAll(const NODE* head)
{
const NODE* p = head;
while(p)
{
printf("%d ",p -> data);
p = p -> next;// 向后遍历
// p = p -> prev;// 向前遍历
}
printf("\n");
}

修改链表

我们也可以针对链表中的数据进行修改，只需要提供一个修改的源数据和目标数据即可。 示例代码如下：

int dlist_update(const NODE* head,DATA old,DATA newdata)
{
NODE* pFind = NULL;
if(pFind = dlist_find(head,old))
{
pFind -> data = newdata;
return 0;
}
return -1;
}

销毁链表

由于链表中的各个节点被离散地分布在各个随机的内存空间，因此销毁链表必须遍历每一个节点，释 放每一个节点。

注意：

销毁链表时，遍历节点要注意不能弄丢相邻节点的指针

示例代码如下：

void dlist_destroy(NODE** head)
{
NODE *p = *head, *q = NULL;
while(p)
{
q = p;
p = p -> next;
free(q);
}
*head = NULL;
}

完整案例

dlist.h

#ifndef __DLIST_H
#define __DLIST_H
typedef int DATA;
typedef struct node
{
DATA data;
struct node *prev;// 前驱指针
struct node *next;// 后继指针
}NODE;
// 创建链表（初始化）
int dlist_create(NODE**,DATA);
// 向链表插入数据（头插法）
int dlist_addHead(NODE** head,DATA data);
// 向链表插入数据（尾插法）
int dlist_addTail(NODE** head,DATA data);
// 向链表插入数据（中间插法）
int dlist_insert(NODE** head,DATA pos,DATA data);
// 链表数据查询
NODE* dlist_find(const NODE* head,DATA data);
// 链表数据更新
int dlist_update(const NODE* head,DATA old,DATA newdata);
// 链表数据遍历
void dlist_showAll(const NODE* head);
// 链表数据删除
int dlist_delete(NODE** head,DATA data);
// 链表回收
void dlist_destroy(NODE** head);
#endif
#include "dlist.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
int dlist_create(NODE** head,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> prev = pNew -> next = NULL;
*head = pNew;
return 0;
}
int dlist_addHead(NODE** head,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> prev = NULL;
pNew -> next = *head;
if(*head)
(*head) -> prev = pNew;
*head = pNew;
return 0;
}
int dlist_addTail(NODE** head,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> prev = NULL;
pNew -> next = NULL;
NODE* p = *head;
if(!p)
{
*head = pNew;
return 0;
}
while(p -> next)
{
p = p -> next;
}
p -> next = pNew;
pNew -> prev = p;
return 0;
}
int dlist_insert(NODE** head,DATA pos,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> prev = NULL;
pNew -> next = NULL;
NODE* p = *head, *q = NULL;
if(!p)
{
*head = pNew;
return 0;
}
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = p;
p -> prev = pNew;
*head = pNew;
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = p;
pNew -> prev = q;
p -> prev = pNew;
q -> next = pNew;
return 0;
}
q = p;
p = p -> next;
}
q -> next = pNew;
pNew -> prev = q;
return 0;
}
int dlist_delete(NODE** head,DATA data)
{
NODE* p = *head;
if(!p)
return -1;
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
if(p -> next == NULL)
{
*head = NULL;
free(p);
return 0;
}
*head = p -> next;
p -> next -> prev = NULL;
free(p);
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
p -> prev -> next = p -> next;
if(p -> next == NULL)
p -> prev -> next = NULL;
else
p -> next -> prev = p -> prev;
free(p) ;
return 0;
}
p = p -> next;
}
return -1;
}
NODE* dlist_find(const NODE* head,DATA data)
{
const NODE* p = head;
while(p)
{
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
return (NODE*)p;
p = p -> next;
}
return NULL;
}
int dlist_update(const NODE* head,DATA old,DATA newdata)
{
NODE* pFind = NULL;
if(pFind = dlist_find(head,old))
{
pFind -> data = newdata;
return 0;
}
return -1;
}
void dlist_destroy(NODE** head)
{
NODE *p = *head, *q = NULL;
while(p)
{
q = p;
p = p -> next;
free(q);
}
*head = NULL;
}
void dlist_showAll(const NODE* head)
{
const NODE* p = head;
while(p)
{
printf("%d ",p -> data);
p = p -> next;
}
printf("\n");
}

dlist_main.c

#include "dlist.h"
#include <stdio.h>
#define OP 2
int main(void)
{
NODE* head = NULL;
int a[] = {1,3,5,7,9};
int n = sizeof a / sizeof a[0];
register int i = 0;
for(; i < n; i++)
dlist_addTail(&head,a[i]);
dlist_showAll(head);
while(1)
{
#if (OP == 0)
DATA data;
NODE *pFind = NULL;
printf("请输入要查找的数据(-1 退出):");
scanf("%d",&data);
if(data == -1)
break;
if(!(pFind = dlist_find(head,data)))
{
puts("查找的数据不存在,请重试...");
continue;
}
printf("在内存地址为 %p 的内存空间中找到了 %d\n",&(pFind->data),pFind->data);
#elif (OP == 1)
DATA data;
NODE *pFind = NULL;
printf("请输入要插入位置的数据(-1 退出):");
scanf("%d",&data);
if(data == -1)
break;
if(dlist_insert(&head,data,407))
{
puts("插入失败,请重试...");
continue;
}
dlist_showAll(head);
#else
DATA data;
NODE *pFind = NULL;
printf("请输入要删除位置的数据(-1 退出):");
scanf("%d",&data);
if(data == -1)
break;
if(dlist_delete(&head,data))
{
puts("删除失败,请重试...");
continue;
}
dlist_showAll(head);
#endif
}
dlist_destroy(&head);
puts("=====回收后====");
dlist_showAll(head);
return 0;
}

循环双向链表【扩展】

案例代码

循环双向链表是在双向链表的基础上进行了改动，整体改动不是很大，请看下面代码：

dclist.h

#ifndef __DCLIST_H
#define __DCLIST_H
typedef int DATA;
typedef struct node
{
DATA data;
struct node *prev;
struct node *next;
}NODE;
int dclist_add(NODE** head,DATA data);
int dclist_delete(NODE** head,DATA data);
NODE* dclist_find(const NODE* head,DATA data);
int dclist_update(const NODE* head,DATA old,DATA newdata);
void dclist_showAll(const NODE* head);
void dclist_destroy(NODE** head);
#endif

dclist.c

#include "dclist.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
static NODE* dclist_create_node(DATA data)
{
NODE* p = (NODE*)malloc(sizeof(NODE));
if(!p)
return NULL;
p -> data = data;
p -> prev = p;
p -> next = p;
return p;
}
/*
@argument: new: 待插入的节点
@argument: prev: 插入后节点的上一个节点
@argument: next: 插入后节点的下一个节点
*/
static void __dclist_add(NODE* new, NODE* prev,NODE* next )
{
new -> prev = prev;
new -> next = next;
prev -> next = new;
next -> prev = new;
}
int dclist_add(NODE** head,DATA data)
{
if(*head == NULL)
{
*head = dclist_create_node(data);
int ret = (*head)?0:-1;
return ret ;
}
NODE *new = dclist_create_node(data);
if(!new)
return -1;
__dclist_add(new,(*head)->prev,*head);
return 0;
}
static void __dclist_delete(NODE* del, NODE* prev,NODE* next )
{
prev -> next = next;
next -> prev = prev;
free(del);
}
int dclist_delete(NODE** head,DATA data)
{
if(*head == NULL)
return -1 ;
NODE *del = dclist_find(*head,data);
if(!del)
return -1;
NODE* p = *head;
if(del == p) //删除的是头节点
{
if(p -> next == p) // 唯一的头节点
{
*head = NULL;
free(p);
return 0;
}
p -> prev -> next = p -> next;
p -> next -> prev = p -> prev;
*head = p -> next;
free(p);
return 0;
}
__dclist_delete(del,del->prev,del->next);
return 0;
}
NODE* dclist_find(const NODE* head,DATA data)
{
const NODE* p = head;
while(p)
{
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
return (NODE*)p;
p = p -> next;
if(p == head)
break;
}
return NULL;
}
int dclist_update(const NODE* head,DATA old,DATA newdata)
{
NODE* pFind = dclist_find(head,old);
if(!pFind)
return -1;
pFind -> data = newdata;
return 0;
}
void dclist_showAll(const NODE* head)
{
const NODE* p = head;
while(p)
{
printf("%d ",p -> data);
p = p -> next;
if(p == head)
break;
}
printf("\n");
}
void dclist_destroy(NODE** head)
{
if(*head == NULL)
return ;
NODE* p = *head,*q = NULL;
p -> prev -> next = NULL;
while(p)
{
q = p ;
p = p -> next;
free(q);
if(p == *head)
break;
}
*head = NULL;
}

dclist_main.c

#include <stdio.h>
#include "dclist.h"
#define DELETE
int main(void)
{
NODE* head = NULL;
int a[] = {1,3,5,7,9,11,13};
int n = sizeof a / sizeof a[0];
register int i = 0;
for(; i < n ; i++)
dclist_add(&head,a[i]);
dclist_showAll(head);
DATA data ;
while(1)
{
#ifdef DELETE
printf("请输入要删除的数据:");
scanf("%d",&data);
if(data == -1)
break;
if(dclist_delete(&head,data) < 0)
{
puts("删除失败,请重试");
continue;
}
dclist_showAll(head);
#else
NODE *pFind = NULL;
printf("请输入要查找的数据:");
scanf("%d",&data);
if(data == -1)
break;
if(!(pFind = dclist_find(head,data)))
{
puts("查找的数据不存在,请重试");
continue;
}
printf("查找数据:%d 内存地址:%p\n",pFind -> data, &(pFind -> data));
#endif
}
dclist_destroy(&head);
puts("====销毁后=====");
dclist_showAll(head);
return 0;
}

适用场合

经过单链表、双链表的学习，可以总结链表的适用场合：

适合用于节点数目不固定，动态变化较大的场合

适合用于节点需要频繁插入、删除的场合 适合用于对节点查找效率不十分敏感的场合

内存监测(valgrind)

安装: sudo apt-get install valgrind
格式: valgrind [options] prog-and-args
例子： valgrind --tool=memcheck --leak-check=full --log-file=./result.txt ./dlist
注意: 在使用valgrind 工具进行内存监测时，要求可执行程序在编译时，要为gcc 编译器指定 -g 选项；

章节作业

（双向循环链表）

【1】用双向循环链表存储若干自然数，并将其奇偶重排输出。

比如：

链表中存储： 1 2 3 4 5 6 7 8 9 …

将其重排成： 1 3 5 7 9 … 8 6 4 2 （奇数升序偶数降序）

解析 从右到左，从最末一个元素开始往前遍历；遇到奇数记下位置，遇到偶数则移动到链表的末尾。

示例代码

// 双向循环链表：奇偶数重排
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
// 链表节点
typedef struct DNode
{
int data;
struct DNode *prior;
struct DNode *next;
}DNode, *DLinkList;
void perror_exit(const char *info)
{
perror(info);
exit(0);
}
/*************************
initialize the list
**************************/
void init_list(DLinkList *p2head)
{
if((*p2head=(DNode *)malloc(sizeof(DNode))) == NULL){
perror("malloc faild");
exit(1);
}
(*p2head)->prior = (*p2head)->next = *p2head;
}
/****************
insert node
*****************/
void insert(DLinkList head, int num)
{
DLinkList pnew;
if((pnew=(DNode *)malloc(sizeof(DNode))) == NULL)
perror_exit("malloc failed");
pnew->data = num;
/***********************************************
insert the new node onto the tail
***********************************************/
pnew->prior = head->prior;
head->prior->next = pnew;
pnew->next = head;
head->prior = pnew;
}
/********************
change the list
*********************/
void rerange(DLinkList old_list, DLinkList new_list)
{
DLinkList p = old_list->next;
//check the next two elements, prevent recycling
while((p->next!=old_list) && (p->next->next!=old_list)){
insert(new_list, p->data);
p = p->next->next;
}
//the list endup with an odd number
if(p->next == old_list){
insert(new_list, p->data);
p = p->prior;
if(p != old_list){
while(p->prior->prior!=old_list){
insert(new_list, p->data);
p = p->prior->prior;
}
insert(new_list, p->data);
}
}
//the list endup with an even number
else{
insert(new_list, p->data);
p = p->next;
insert(new_list, p->data);
while(p->prior->prior!=old_list){
p = p->prior->prior;
insert(new_list, p->data);
}
}
}
/*************
show list
**************/
void show(DLinkList head)
{
DNode *p=head->next;
while(1){
printf("%d ", p->data);
if(p->next == head)
break;
p = p->next;
}
printf("\n");
}
int main(int argc, char **argv)
{
int n;
scanf("%d", &n); // 输入所需链表的长度
// 创建空链表
DLinkList head;
init_list(&head);
// 依次插入节点
int i;
for(i=n; i>0; --i)
{
insert(head, n-i+1);
}
show(head);
/* arange the list */
DLinkList new_list;
init_list(&new_list);
rerange(head, new_list);
show(new_list);
return 0;
}

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

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

相关文章

FPGA 如何进入 AI 领域的思考

FPGA 如何进入 AI 领域的思考

FPGA在AI领域如何发力&#xff0c;如何抢碗饭吃&#xff1f;大多数提到是硬件加速&#xff0c;在AI工程里&#xff0c;完成数据前处理&#xff08;加速&#xff09;。大家很少提到AI模型的本身的推理过程&#xff0c;让FPGA成为AI模型的推理/算力芯片&#xff0c;这自然是 FPGA…
阅读更多...
2535. 解密 [CSP-J 2022]

2535. 解密 [CSP-J 2022]

代码 #include <bits/stdc.h> using namespace std; long long m,n; int check(int x){if(x * (m - x) n) return 0;if(x * (m - x) < n) return 1;if(x * (m - x) > n) return 2; } int main(){int k;cin >> k;while(k--){long long e, d,p0,q0;scanf(&q…
阅读更多...
如何抠去PPT图片的背景？推荐这款AI智能抠图软件！

如何抠去PPT图片的背景？推荐这款AI智能抠图软件！

做ppt的过程中&#xff0c;我们会用到各式各样的图片素材&#xff0c;其中有些图片不能完全满足我们的需求&#xff0c;得先对图片进行处理&#xff0c;最常见的是抠图&#xff0c;去除图片原有的背景&#xff0c;得到一张包含透明像素的图片&#xff0c;方便我们排版PPT页面上…
阅读更多...
高德企业用车负责人：以AI技术革新出行服务体验

高德企业用车负责人：以AI技术革新出行服务体验

在助力产业数字化转型的大潮中&#xff0c;高德企业用车以其前沿的科技理念和创新服务&#xff0c;正在成为出行领域的领跑者。近日接受采访时&#xff0c;高德地图行业合作业务总经理姜义丹先生分享了AI技术在出行领域应用的思考&#xff0c;以及如何提升企业服务智能化水平&a…
阅读更多...
【C/C++】typedef用法

【C/C++】typedef用法

typedef用法讲解&#xff0c;时隔半年&#xff0c;再看typedef。 &#x1f381;typedef可以简化结构体关键字 #include<iostream> using namespace std;struct Person {char name[64];int age; };void test01() {struct Person p { "张三",18 };//不用type…
阅读更多...
005、架构_数据节点

005、架构_数据节点

​DN组件总览 ​ DN节点包含进程 dbagent进程：主要提供数据节点高可用、数据导入导出、数据备份恢复、事务一致性、运维类功能、集群的扩缩容、卸数等功能；MySQL进程：主要提供数据一致性、分组管理、快同步复制、高低水位等；
阅读更多...
卡在恢复模式怎么办？这样操作一键轻松退出iPhone 恢复模式

卡在恢复模式怎么办？这样操作一键轻松退出iPhone 恢复模式

iOS 18beta版本发布后&#xff0c;已经成功升级到iOS 18beta并享受新功能的小伙伴们真是太幸运了。但是还有一些小伙伴在更新iOS 18beta的过程中遇到了各种问题&#xff0c;比如iPhone卡在恢复模式是常见问题。如果你也遇到此问题&#xff0c;不要着急&#xff0c;接下来我们将…
阅读更多...
Graylog日志丢失解决方案

Graylog日志丢失解决方案

问题描述 目前公司使用的日志方案是Graylog5.0版本&#xff0c;当接入的日志并发多时&#xff0c;就会出现日志丢失的情况。 目前硬件系统centos7.9 内核5.16.13。一台graylog和一台es服务器。 两台机器硬件配置 graylog CPU 36C 内存 150G 系统硬盘 500G &#xff08;固态&…
阅读更多...
[论文阅读] mobile aloha实验部分

[论文阅读] mobile aloha实验部分

DP:[1] CHI C, FENG S, DU Y, et al. Diffusion Policy: Visuomotor Policy Learning via Action Diffusion[J]. 2023. Diffusion Policy: Visuomotor Policy Learning via Action Diffusion精读笔记&#xff08;一&#xff09;-CSDN博客 哥伦比亚大学突破性的方法- Diffusio…
阅读更多...
Android中apk安装过程源码解析

Android中apk安装过程源码解析

本文中使用的Android源码基于Android 14 1 三方应用安装apk调用方法 public void installApk() {Intent intent new Intent(Intent.ACTION_VIEW);intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);/** 自Android N开始&#xff0c;是通过FileProvider共享相关文件&#xff0…
阅读更多...
git提交本地项目到远程仓库

git提交本地项目到远程仓库

1、查看项目目录&#xff0c;是否存在.git文件夹&#xff08;若存在则删除&#xff09; 2、登录git并新建一个空白项目 3、idea创建本地git仓库&#xff08;选择本地项目&#xff09; 4、添加要提交的项目&#xff08;项目右键&#xff09; 5、提交代码到本地仓库 6、配置远程…
阅读更多...
SQLserver中的游标的分类和游标的生命周期

SQLserver中的游标的分类和游标的生命周期

SQLserver中的游标的分类 在 SQL Server 中&#xff0c;游标&#xff08;Cursor&#xff09;是一种数据库对象&#xff0c;用于逐行处理结果集中的数据。游标可以用于复杂的数据处理任务&#xff0c;尤其是那些不能通过简单的 SELECT 语句和 JOIN 操作完成的任务。SQL Server …
阅读更多...
48.x86游戏实战-封包抓取进图call

48.x86游戏实战-封包抓取进图call

免责声明&#xff1a;内容仅供学习参考&#xff0c;请合法利用知识&#xff0c;禁止进行违法犯罪活动&#xff01; 本次游戏没法给 内容参考于&#xff1a;微尘网络安全 工具下载&#xff1a; 链接&#xff1a;https://pan.baidu.com/s/1rEEJnt85npn7N38Ai0_F2Q?pwd6tw3 提…
阅读更多...
OpenAI API: How to count tokens before API request

OpenAI API: How to count tokens before API request

题意&#xff1a;“OpenAI API&#xff1a;如何在 API 请求之前计算令牌数量” 问题背景&#xff1a; I would like to count the tokens of my OpenAI API request in R before sending it (version gpt-3.5-turbo). Since the OpenAI API has rate limits, this seems impor…
阅读更多...
OpenLayers3,地图探查功能实现

OpenLayers3,地图探查功能实现

文章目录 一、前言二、代码实现三、总结 一、前言 图层探查&#xff0c;即对置于地图下方的图层进行一定范围的探查&#xff0c;以便用户查看到不易察觉的地理地况。本文基于OpenLayers3&#xff0c;实现地图探查的功能。 二、代码实现 <!DOCTYPE HTML PUBLIC "-//W…
阅读更多...
基于Transformer架构的大模型推理硬件加速器设计

基于Transformer架构的大模型推理硬件加速器设计

概述 当前大模型的基础架构正在向 Transformer 结构收敛1&#xff0c;Transformer架构自谷歌2017年提出后比较稳定&#xff0c;因此针对Transformer的计算设计专用的ASIC加速器很有必要。 尤其是“Attention is All you Need”》“Money is All you Need”&#xff0c;哈哈哈…
阅读更多...
MySQL的源码安装及基本部署(基于RHEL7.9)

MySQL的源码安装及基本部署(基于RHEL7.9)

这里源码安装mysql的5.7.44版本 一、源码安装 1.下载并解压mysql , 进入目录: wget https://downloads.mysql.com/archives/get/p/23/file/mysql-boost-5.7.44.tar.gz tar xf mysql-boost-5.7.44.tar.gz cd mysql-5.7.44/ 2.准备好mysql编译安装依赖: yum install cmake g…
阅读更多...
使用vueuse在组件内复用模板

使用vueuse在组件内复用模板

1. 安装vueusae pnpm i vueuse/core2. 组件内复用模板 createReusableTemplate 是vueuse中的一个实用工具&#xff0c;用于在 Vue 3 中创建可重复使用的模板片段&#xff0c;同时保持状态的独立性。这对于需要在多个组件中重复使用相同的结构和逻辑时非常有用。 因为这些可复…
阅读更多...
链表OJ题——使用栈实现单链表的逆序打印

链表OJ题——使用栈实现单链表的逆序打印

文章目录 一、题目链接二、解题思路三、解题代码 一、题目链接 题目描述&#xff1a;使用栈&#xff0c;实现单链表的逆序打印 二、解题思路 三、解题代码 /*** 非递归实现单链表的顶逆序打印——>通过栈来实现* param*/public void printReverseListFromStack(){Stack<…
阅读更多...
短视频SDK解决方案，原开发团队，一对一技术支持

短视频SDK解决方案，原开发团队，一对一技术支持

美摄科技&#xff0c;作为行业领先的视频技术提供商&#xff0c;凭借深厚的技术积累和敏锐的市场洞察&#xff0c;隆重推出其短视频SDK解决方案&#xff0c;旨在为全球开发者及内容创作者搭建一座通往无限创意与高效生产的桥梁。 【一站式解决方案&#xff0c;赋能创意无界】 …
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023