数据结构代码分享

news/2024/9/18 3:06:29/ 标签: 数据结构

单向链表

slist.h
#ifndef __SLIST_H
#define __SLIST_H#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>// 定义单链表结构
typedef int DATA;typedef struct Node
{DATA data;		    // 存储数据---数据域struct Node *next;  // 存储下一个节点的地址---指针域
} NODE;// 链表创建
int slist_create(NODE**,DATA);】.// 向链表头部插入一个节点数据（头插法）
int slist_addHead(NODE**,DATA);// 向链表尾部插入一个节点数据（尾插法）
int slist_addTail(NODE**,DATA);// 向链表中间插入一个节点数据（中间插法）
int slist_insert(NODE**,DATA,DATA);// 遍历链表数据
void slist_showAll(const NODE* head);// 回收链表
void slist_destroy(NODE** head);// 链表数据查询
NODE* slist_find(const NODE *head,DATA data);
// 更新链表数据
int slist_update(const NODE *head,DATA old_data,DATA new_data);// 删除链表数据（剔除节点，不是真正意义上的删除）
int slist_delete(NODE**,DATA);#endifslist.c
#include "slist.h"/*
@function:   int slist_create(NODE** head,DATA data);
@berif:      创建单项链表
@argument:   head: 指向头指针变量的地址，用来接收首节点地址data: 存储在节点中的数据
@return :    成功返回 0失败返回 -1
*/
int slist_create(NODE **head, DATA data)
{// 申请内存NODE *p = (NODE *)malloc(sizeof(NODE));// 校验if (!p){return -1;}// 赋值操作p->data = data;p->next = NULL;*head = p;return 0;
}/*
@function:   int slist_addHead(NODE** head,DATA data);
@berif:      向链表头部插入一个节点数据（头插法）
@argument:   head: 指向头指针变量的地址，用来接收首节点地址data: 存储在新节点中的数据
@return :    成功返回 0失败返回 -1
*/
int slist_addHead(NODE **head, DATA data)
{// 创建一个新节点（申请内存）NODE *p = (NODE *)malloc(sizeof(NODE));// 校验if (!p){return -1;}// 给节点添加新数据（创建节点的目的是存储数据）p->data = data;// 新节点指向原本的head节点p->next = *head;// 我们要让p作为我们新的head*head = p;return 0;
}/*
@function:   int slist_addTail(NODE** head,DATA data);
@berif:      向链表尾部插入一个节点数据（尾插法）
@argument:   head: 指向头指针变量的地址，用来接收首节点地址data: 存储在新节点中的数据
@return :    成功返回 0失败返回 -1
*/
int slist_addTail(NODE **head, DATA data)
{// 创建一个新节点（申请内存）NODE *pNew = (NODE *)malloc(sizeof(NODE));// 校验if (!pNew){return -1;}// 赋值操作pNew->data = data; // 存数据pNew->next = NULL; // 因为是最后一个节点，所有没有指向// 获取尾部节点，默认head头结点就是尾结点，p用来保存真实的尾结点NODE *p = *head, *q = NULL;if (!p){// 如果说头节点不存在，我们直接将新节点作为头结点，一般不会发生*head = pNew;return 0;}// 通过一个循环，找尾结点while (p){// 为什么要定义q，因为p是在变化的q = p;p = p->next;// 指针向下指}// 让原本的尾结点指向新插入的的节点，此时新插入的节点变成了尾结点q->next = pNew;return 0;
}/*
@function:   int slist_insert(NODE** head,DATA pos ,DATA data);
@berif:      向链表节点值为pos的位置插入一个节点数据data
@argument:   head: 指向头指针变量的地址pos:  插入节点位置的节点数据data: 存储在新节点中的数据
@return :    成功返回 0失败返回 -1
*/
int slist_insert(NODE** head,DATA pos,DATA data)
{// 创建一个新节点，并申请内存NODE *pNew = (NODE*)malloc(sizeof(NODE));if(!pNew){
perror("内存申请失败！");return -1;}// 给新节点赋初值pNew->data = data;pNew->next = NULL;// 声明变量，p是pos对应位置的节点，默认是头结点，q是pos对应节点的上一个节点NODE *p = *head,*q = NULL;// 第一种情况：头结点不存在if(!p){// 新节点pNew作为头结点*head = pNew;return 0;}// 第二种情况：只有头结点if(memcmp(&(p->data),&pos,sizeof(DATA)) == 0){// 头插法// 新节点的next指向head节点pNew->next = *head;// 改变指向，将pNew作为新的头结点*head = pNew;return 0;}// 第三种情况：既有头结点，也有普通节点while (p){// 找pos对应位置的节点if(memcmp(&(p->data),&pos,sizeof(DATA)) == 0){// pNew在p前pNew->next = p;// pNew在q后q->next = pNew;return 0;}q = p;// q在p的前一位，一前（q）一后（p）p = p ->next;}// 尾插法q->next = pNew;return 0;
}/*
@function:   NODE* slist_find(const NODE* head,DATA data);
@berif:      查找链表数据data
@argument:   head: 指向头指针变量data: 待查找的数据
@return :    成功返回节点的地址失败返回NULL
*/
NODE* slist_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;
}/*
@function:   int slist_update(const NODE* head,DATA old_data,DATA new_data);
@berif:      更新链表数据old_data 为 new_data
@argument:   head: 指向头指针变量old_data:  待更新的节点数据new_data: 更新后的节点数据
@return :    成功返回  0失败返回  -1
*/
int slist_update(const NODE* head,DATA old_data,DATA new_data)
{NODE* p = NULL;if(!(p = slist_find(head,old_data))){return -1;}p->data = new_data;return 0;}/*
@function:   void slist_showAll(const NODE* head);
@berif:      遍历链表数据
@argument:   head: 指向头指针变量
@return :    无
*/
void slist_showAll(const NODE* head)
{// 创建一个变量用来接收链表const NODE* p = head;// 遍历链表while (p){printf("%d ",p->data);p = p->next;}printf("\n");}/*
@function:   int slist_delete(NODE** head,DATA data);
@berif:      删除链表中节点值为data的节点
@argument:   head: 指向头指针变量的地址data: 删除节点中的数据
@return :    成功返回 0失败返回 -1
*/
int slist_delete(NODE** head,DATA data)
{// 指针尾随NODE *p = *head,*q = NULL;// 第一种情况：头结点不存在（链表本身不存在），无法操作if(!p){return -1; }// 第二种情况：只有一个节点if(memcmp(&(p->data),&data,sizeof(DATA)) == 0){*head = p -> next;free(p);return 0;}// 第三种情况：有多个节点while (p){if(memcmp(&(p->data),&data,sizeof(DATA)) == 0){q->next = p->next;// p的上一个节点的next指向p的下一个节点// 这个回收不会影响到链表的删除free(p);return 0;}q = p;p = p->next;// p->next代表的是p的下一个节点，将p的下一个节点赋值给p，相当于p移动了一位}return -1;}/*
@function:   void slist_destroy(NODE** head);
@berif:      回收链表
@argument:   head: 指向头指针变量的地址
@return :    无
*/
void slist_destroy(NODE** head)
{// 指针尾随NODE *p = *head,*q = NULL;while(p){
q = p;// 12p = p->next;// 13// 回收前一个节点free(q);}*head = NULL;}Slist_main.c
#include "slist.h"
#define DELETE 1
int main()
{NODE *head = NULL;if (slist_create(&head, 888) < 0){perror("单链表创建失败！");// exit(0);return -1;}printf("单链表创建成功！\n");slist_addTail(&head, 999);slist_addTail(&head, 222);slist_addTail(&head, 666);slist_addTail(&head, 777);// 运行效果：999 222 666 777slist_addHead(&head, 555);// 运行效果：555 999 222 666 777slist_insert(&head, 555, 1024);// 运行效果：1024 555 999 222 666 777slist_insert(&head, 222, 1080);// 运行效果：1024 555 999 1080 222 666 777slist_showAll(head);DATA data;while (1){
#ifdef DELETEprintf("请输入要删除的数据:");scanf("%d", &data);if (data == -1)break;if (slist_delete(&head, data) < 0){puts("删除失败,请重试");continue;}slist_showAll(head);
#elseNODE *pFind = NULL;DATA newdata = 512;printf("请输入要查找的数据:");scanf("%d", &data);if (data == -1)break;// if(!(pFind = slist_find(head,data)))if (slist_update(head, data, newdata) == -1){puts("查找的数据不存在,请重试");continue;}// printf("查找数据:%d  内存地址:%p\n",pFind -> data, &(pFind -> data));slist_showAll(head);
#endif}slist_destroy(&head);puts("====销毁后====");slist_showAll(head);return 0;
}

双向链表

dlist.h
#ifndef __DLIST_H
#define __DLIST_H#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>// 定义链表节点中数据的类型，本次案例使用int类型
typedef int DATA;// 定义节点
typedef struct node
{DATA          data; // 数据struct  node *prev; // 前驱指针struct  node *next; // 后继指针
}NODE;// 创建链表（初始化）
int dlist_create(NODE**,DATA);// 向链表头部插入数据（头插法）
int dlist_addHead(NODE**,DATA);// 向链表尾部插入数据（尾插法）
int dlist_addTail(NODE**,DATA);// 向链表任意位置插入数据（中间插法）
int dlist_insert(NODE**,DATA,DATA);// 链表数据遍历
void dlist_showAll(const NODE*);// 链表数据查询
NODE* dlist_find(const NODE*,DATA);
// 链表数据更新
int dlist_update(const NODE*,DATA,DATA);// 链表数据删除
int dlist_delete(NODE**,DATA);// 链表回收
void dlist_destroy(NODE**);
#endifdlist.c
#include "dlist.h"/*** @function:   int dlist_create(NODE**,DATA);* @berif:      创建双向链表* @argument:   head: 指向头指针变量的地址，用来接收首节点地址*              data: 存储在节点中的数据* @return :    成功返回 0*              失败返回 -1*/
int dlist_create(NODE **head, DATA data)
{// 创建一个节点（申请内存）NODE *pNew = (NODE *)malloc(sizeof(NODE));if (!pNew){perror("内存申请失败！");return -1;}// 节点的初始化pNew->data = data;pNew->prev = pNew->next = NULL; // 给前驱指针和后继指针都赋值为NULL// 将pNew作为头结点*head = pNew;return 0;
}/*** @function:   int dlist_addHead(NODE**,DATA);* @berif:      向链表头部插入数据* @argument:   head: 指向头指针变量的地址，用来接收首节点地址*              data: 存储在节点中的数据* @return :    成功返回 0*              失败返回 -1*/
int dlist_addHead(NODE **head, DATA data)
{// 创建一个节点，申请内存NODE *pNew = (NODE *)malloc(sizeof(NODE));// 校验if (!pNew){perror("内存申请失败！");return -1;}// 给节点赋值pNew->data = data;pNew->prev = NULL;pNew->next = *head;// 如果头结点存在，需要设置head.prev指向pNewif (*head){(*head)->prev = pNew;}// 将pNew作为新的头结点*head = pNew;return 0;
}/*** @function:   int dlist_addTail(NODE**,DATA);* @berif:      向链表尾部插入数据* @argument:   head: 指向头指针变量的地址，用来接收首节点地址*              data: 存储在节点中的数据* @return :    成功返回 0*              失败返回 -1*/
int dlist_addTail(NODE **head, DATA data)
{// 创建一个节点，申请内存
NODE *pNew = (NODE *)malloc(sizeof(NODE));if (!pNew){perror("内存申请失败！");return -1;}// 给节点赋初值pNew->data = data;pNew->prev = pNew->next = NULL;// 定义一个变量，用来存储尾结点NODE *p = *head;// 第一种情况：没有节点，pNew作为头结点if (!p){*head = pNew;return 0;}// 第二种情况：有节点，向末尾添加pNewwhile (p->next){// 移动p的位置p = p->next;}// 末尾的p节点跟pNew建立联系，此时pNew称为尾结点p->next = pNew;pNew->prev = p;return 0;
}/*** @function:   int dlist_insert(NODE**,DATA,DATA);* @berif:      向链表任意位置插入数据（中间插法）* @argument:   head: 指向头指针变量的地址，用来接收首节点地址*              pos：目标位置数据*              data: 存储在节点中的数据* @return :    成功返回 0*              失败返回 -1*/
int dlist_insert(NODE **head, DATA pos, DATA data)
{// 创建节点，申请内存NODE *pNew = (NODE *)malloc(sizeof(NODE));if (!pNew){perror("内存申请失败！");return -1;}// 给节点赋初值pNew->data = data;pNew->prev = pNew->next = NULL;NODE *p = *head, *q = NULL;// 第一种情况：没有节点，pNew作为头结点if (!p){*head = pNew;return 0;}// 第二种情况：pos对应的节点刚好是头结点（有效节点是头结点，只有一个节点的时候）if (memcmp(&(p->data), &pos, sizeof(DATA)) == 0){pNew->next = p;p->prev = pNew;*head = pNew;return 0;}// 第三种情况：pos对应的节点不是头结点（有效节点超过两个）while (p) // p 判断当前节点是否为NULL，p->next 判断写一个节点是否为NULL{if (memcmp(&(p->data), &pos, sizeof(DATA)) == 0){pNew->next = p;pNew->prev = q;p->prev = pNew;q->next = pNew;return 0;}// 记录当前位置（上一个节点的位置）q = p;// 记录下一个节点的位置，也就是更新后的pp = p->next;}// 如果在链表中找不到pos对应的节点，就尾插q->next = pNew;pNew->prev = q;return 0;
}/*** @function:   void dlist_showAll(const NODE*);* @berif:      向链表任意位置插入数据（中间插法）* @argument:   head: 指向头指针变量的地址，用来接收首节点地址*              pos：目标位置数据*              data: 存储在节点中的数据* @return :    成功返回 0*              失败返回 -1*/
void dlist_showAll(const NODE *head)
{const NODE *p = head;while (p){printf("%d ", p->data);// 向后遍历p = p->next;// 向前遍历// p = p->prev;}printf("\n");
}/*** @function:   NODE* dlist_find(const NODE*,DATA);* @berif:      链表数据查询（根据指定的数据查找节点）* @argument:   head: 指向头指针变量的地址，用来接收首节点地址*              data: 要检索的数据* @return :    成功返回 NODE**              失败返回 NULL*/
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;
}//
/*** @function:   dlist_update(const NODE*,DATA,DATA);* @berif:      链表数据更新* @argument:   head: 指向头指针变量的地址，用来接收首节点地址*              old_data：源数据*              new_data: 目标数据* @return :    成功返回 0*              失败返回 -1*/
int dlist_update(const NODE *head, DATA old_data, DATA new_data)
{// 用来接收查询到的节点NODE *pFind = NULL;// 利用刚刚写的查询函数，查询if (!(pFind = dlist_find(head, old_data))){return -1;}// 更新数据pFind->data = new_data;return 0;
}/*** @function:   dlist_delete(NODE**,DATA);* @berif:      链表数据删除* @argument:   head: 指向头指针变量的地址，用来接收首节点地址*              data: 需要删除的数据* @return :    成功返回 0*              失败返回 -1*/
int dlist_delete(NODE **head, DATA data)
{// 记录需要删除的节点的位置NODE *p = *head;// 第一种情况：链表不存在if (!p){return -1;}// 第二种情况：删除的数据对应的节点正好是头结点if (memcmp(&(p->data), &data, sizeof(DATA)) == 0){// 1. 链表中只有一个节点if (p->next == NULL){free(p);*head = NULL;return 0;}// 2. 链表中有两个以上节点// 执行下列代码之前，head和p都指向头结点，下面代码的意思是：将p节点的下一个节点作为新的头结点*head = p->next;// 解除p的引用关系(下一个节点指向它的关系)p->next->prev = NULL;// 回收pfree(p);return 0;}// 正常删除：链表中要删除的节点不是头结点while (p){if (memcmp(&(p->data), &data, sizeof(DATA)) == 0){// p的上一个节点的next指向p的下一个节点p->prev->next = p->next;// p是尾结点if(p->next==NULL){// 解除p的上一个节点跟p的引用p->prev->next = NULL;}else // p不是尾结点{// p的下一个节点的prev指向p的上一个节点p->next->prev = p->prev;}// 回收解除引用的节点free(p);return 0;}// 改变循环条件p = p->next;}return -1;
}/*** @function:   void dlist_destroy(NODE**);* @berif:      链表回收* @argument:   head: 指向头指针变量的地址，用来接收首节点地址*              old_data：源数据*              new_data: 目标数据* @return :    成功返回 0*              失败返回 -1*/
void dlist_destroy(NODE **head)
{// p记录移动的节点，q记录需要回收的节点NODE *p = *head, *q = NULL;while (p){// 实现指针尾随q = p;       // 前一个节点p = p->next; // 后一个节点// 回收qfree(q);}*head = NULL;
}Dlist_main.c
#include "dlist.h"#define OP 3int main()
{NODE *head = NULL;// if (dlist_create(&head, 666) != -1)// {//     printf("链表创建成功！\n");// }// else// {//     printf("链表创建失败！\n");// }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_addHead(&head, 888);dlist_insert(&head, 5, 999);dlist_showAll(head); // 888 1 3 999 5 7 9while (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);
#elif (OP == 2)DATA data;NODE *pFind = NULL;printf("请输入要修改位置的数据(-1 退出):");scanf("%d", &data);if (data == -1)break;if (dlist_update(head, data, 407)){puts("修改失败,请重试...");continue;}dlist_showAll(head);
#elseDATA 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;
}

顺序队列

squeue.h
#ifndef __SQUEUE_H
#define __SQUEUE_H#include <stdio.h>
#include <stdlib.h>
#include <string.h>// 定义测试的数据类型
typedef int DATA;// 创建顺序队列
typedef struct
{DATA *pData; // 队列入口，也就是我们创建的堆数组，我们入队的所有数据存储在这里int size;    // 队列的总容量（堆数组的大小）int head;    // 队头元素下标int tail;    // 队尾元素下标
} SQueue;// 初始化队列
int SQ_init(SQueue *q, int num);// 判断队列是否已满
int SQ_isfull(SQueue *q);// 判断队尾是否为空
int SQ_isempty(SQueue *q);// 入队
int SQ_push(SQueue *s, DATA data);// 出队
int SQ_pop(SQueue *st, DATA *data);// 回收队列
int SQ_free(SQueue *st);
#endifsqueue.c
#include "squeue.h"// 初始化队列
int SQ_init(SQueue *q, int num)
{// 首先，给pData，也就是堆数组申请空间q->pData = (DATA *)calloc(sizeof(DATA), num);// 校验if (q->pData == NULL){perror("内存申请失败！");return -1;}// 初始化q->size = num;// 默认头尾下标都是0，此时队列为空（当头和尾的下标相等时，队列是空的）q->head = q->tail = 0;return 0;
}// 判断队列是否已满
int SQ_isfull(SQueue *q)
{return (q->tail + 1) % q->size == q->head;
}// 判断队尾是否为空
int SQ_isempty(SQueue *q)
{return q->tail == q->head;
}// 入队
int SQ_push(SQueue *s, DATA data)
{// 判断队列是否已满if (SQ_isfull(s)){return -1;}// 将数据存放到队尾s->pData[s->tail] = data;s->tail = (s->tail + 1) % s->size;return 0;
}// 出队
int SQ_pop(SQueue *st, DATA *data)
{// 判断队列是否为空if (SQ_isempty(st))return -1;*data = st->pData[st->head];st->head = (st->head + 1) % st->size;return 0;
}// 回收队列
int SQ_free(SQueue *st)
{if (st->pData){free(st->pData);st->pData = NULL;}st->head = st->tail = 0;
}Squeue_main.c
#include "squeue.h"
#include <stdio.h>
int main(void)
{SQueue    queue;SQ_init(&queue,10);register  int i = 1;    for(; i <= 10 ; i++) SQ_push(&queue, i);if( -1 == SQ_push(&queue,1024))fprintf(stderr,"满队,入队失败!\n");while(!SQ_isempty(&queue)){DATA   data;SQ_pop(&queue,&data);printf("%4d",data);}printf("\n");SQ_free(&queue);return 0; 
}

栈

sstack.h
#ifndef __SSTACK_H
#define __SSTACK_H#include <stdio.h>
#include <stdlib.h>
#include <string.h>// 定义数据的类型，可以是复杂的结构体，本案例就使用int
// typedef struct Book
// {
//     int id;
//     char *name;
//     int bookId;
//     char *author;
// }DATA;typedef int DATA;// 顺序栈结构体
typedef struct
{DATA *pData;// 栈中元素的地址[12,13,14]int    size;// 顺序栈的大小（数组的大小）int    top; // 栈顶元素下标
}SeqStack;// 初始化栈
int SStack_init(SeqStack *s,int size);// 判断栈是否已满
int SStack_isfull(SeqStack *s);// 判断栈是否为空
int SStack_isempty(SeqStack *s);// 入栈|压栈
int SStack_push(SeqStack *s,DATA data);
// 出栈|弹栈（弹出指定元素）
int SStack_pop(SeqStack *s,DATA *data);// 出栈|弹栈（弹出所有元素）// 回收栈
int SStack_destroy(SeqStack *s);#endifsstack.c
#include "sstack.h"// 初始化栈
int SStack_init(SeqStack *s,int size)
{// 给栈中的元素申请存储空间s->pData = (DATA*)calloc(sizeof(DATA),size);// 校验if(s->pData == NULL){perror("内存申请失败！");return -1;}// 初始化s->size = size;s->top = -1;return 0;
} // 判断栈是否已满
int SStack_isfull(SeqStack *s)
{return s->top + 1 == s->size;
}
// 判断栈是否为空
int SStack_isempty(SeqStack *s)
{return s->top == -1;
}// 入栈|压栈
int SStack_push(SeqStack *s,DATA data){// 判断栈是否已满if(SStack_isfull(s)){printf("顺序栈已填满！\n");return -1;}// 操作栈s->top++;// top向后偏移一位，top自增s->pData[s->top] = data;// 在更新后的top位置插入数据return 0;
}// 出栈|弹栈（弹出指定元素）
int SStack_pop(SeqStack *s,DATA *data)
{// 判断栈是否为空if(SStack_isempty(s)){printf("顺序栈已为空！\n");return -1;}// 将弹出的元素返回*data = s->pData[s->top];// 改变tops->top--;// printf("弹出数据：%d\n",*data);return 0;
}// 回收栈
int SStack_destroy(SeqStack *s){if(s->pData){// 释放内存free(s->pData);s->pData = NULL;}// 重置tops->top = -1;
}Sstack_main.c
#include "sstack.h"int main()
{// 声明顺序栈SeqStack st;// 声明一个变量，用来接收弹出的数据DATA data;// 初始化顺序栈SStack_init(&st,10);for(int i = 0;i<15;i++){// 入栈SStack_push(&st,i);}// 弹栈while(!SStack_isempty(&st)){SStack_pop(&st,&data);printf("%-4d",data);}printf("\n");printf("====回收栈====\n");SStack_destroy(&st);return 0;
}


http://www.ppmy.cn/news/1518581.html

相关文章

英特尔 Arrow Lake Halo 再现，猛堆料对标Strix Halo/苹果M系列

英特尔 Arrow Lake Halo 再现，猛堆料对标Strix Halo/苹果M系列

原文转载修改自&#xff1a; Arrow Lake Halo暴力堆料&#xff0c;对标Strix Halo&#xff0c;M系列 根据最近的消息&#xff0c;蓝厂准备于来年1月推出笔记本Arrow Lake-H处理器。虽然在传闻中Arrow Lake-H又是Arc Alchemist架构革新&#xff0c;又是6P8E&#xff0c;但基于…
阅读更多...
flutter封装Dio使用

flutter封装Dio使用

原文地址 封装 DioHttpUtil 类 // ignore_for_file: constant_identifier_namesimport package:dio/dio.dart; import package:flutter/foundation.dart;
阅读更多...
使用SparkGraphX进行图计算时的编码问题

使用SparkGraphX进行图计算时的编码问题

使用SparkGraphX进行图计算时的编码问题 在SparkGraphX体系中&#xff0c;要求图网络中的点ID必须为Long类型&#xff0c;不像Python中的networkX工具包支持字符串类型的节点表示&#xff0c;但在现实场景中&#xff0c;有很多情况下&#xff0c;点ID都是字符串类型的&#xf…
阅读更多...
网络原理 TCP与UDP协议

网络原理 TCP与UDP协议

博主主页: 码农派大星. 数据结构专栏:Java数据结构 数据库专栏:MySQL数据库 JavaEE专栏:JavaEE 关注博主带你了解更多数据结构知识 1.应用层 之前编写完了基本的 java socket &#xff0c;要知道&#xff0c;我们之前所写的所有代码都在应⽤层&#xff0c;都是为了 完成某项…
阅读更多...
Ubuntu18.04 下安装CUDA

Ubuntu18.04 下安装CUDA

安装步骤 1.查看是否安装了cuda # 法1 cat /usr/local/cuda/version.txt # 法2 nvcc --version 2.若没有安装&#xff0c;则查看是否有N卡驱动&#xff0c;若无N卡驱动&#xff0c;则到软件与更新 -> 附加驱动中安装驱动 3.查看N卡驱动支持的cuda版本 nvidia-smi 如下…
阅读更多...
哪些领域最适合采用音视频私有化解决方案？

哪些领域最适合采用音视频私有化解决方案？

随着数字化时代的到来&#xff0c;音视频通信已成为各行各业不可或缺的一部分&#xff0c;从企业内部沟通到在线教育、远程医疗、金融交易等&#xff0c;无一不依赖于稳定、高效且安全的音视频技术。然而&#xff0c;不同的行业对音视频通信的需求各不相同&#xff0c;尤其在数…
阅读更多...
微信小程序代码目录结构介绍

微信小程序代码目录结构介绍

文件描述app.js小程序的入口文件&#xff0c;负责监听和处理小程序的生命周期函数&#xff0c;以及定义一些全局的公共方法和数据。app.json公共全局配置文件。app.wxss公共全局样式文件。project.config.json项目的配置文件&#xff0c;包含一些项目级别的配置&#xff0c;如项…
阅读更多...
使用Vue创建cesium项目模版该如何选择？

使用Vue创建cesium项目模版该如何选择？

目录 问题描述模版说明及选用建议小结 问题描述 刚入手这个项目&#xff0c;什么都是一知半解。使用Vue,创建Cesium项目的时候&#xff0c;提示需要选择一个模版&#xff08;如下图所示&#xff09;&#xff0c;该如何选择项目模版选&#xff0c;总结如下&#xff1a; 模版说明…
阅读更多...
Django+Vue音乐推荐系统的设计与实现

Django+Vue音乐推荐系统的设计与实现

目录 1 项目介绍2 项目截图3 核心代码3.1 需要的环境3.2 Django接口层3.3 实体类3.4 config.ini3.5 启动类3.5 Vue 4 数据库表设计5 文档参考6 计算机毕设选题推荐7 源码获取 1 项目介绍 博主个人介绍&#xff1a;CSDN认证博客专家&#xff0c;CSDN平台Java领域优质创作者&…
阅读更多...
Java基础入门【第六章 static、继承、重写、多态】（二）

Java基础入门【第六章 static、继承、重写、多态】（二）

5.访问控制 对象中的属性和方法&#xff0c;可以根据不同的权限修饰符&#xff08;public > protected > default > private&#xff09;来进行访问控制。 1&#xff09;概述 类中的属性和方法&#xff0c;可以使用以下四种权限修饰符进行访问控制&#xff1a; pu…
阅读更多...
python列表实现矩阵行列转换

python列表实现矩阵行列转换

本文采用列表嵌套实现矩阵的行列转换。 第一种方法&#xff08;此方法来源于https://docs.python.org/zh-cn/3/tutorial/datastructures.html#list-comprehensions matrix [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], ] print([[row[i] for row in matrix] for i i…
阅读更多...
回归预测|基于粒子群优化核极限学习机PSO-KELM结合Adaboost集成的数据预测Matlab程序 多特征输入单输出

回归预测|基于粒子群优化核极限学习机PSO-KELM结合Adaboost集成的数据预测Matlab程序 多特征输入单输出

回归预测|基于粒子群优化核极限学习机PSO-KELM结合Adaboost集成的数据预测Matlab程序 多特征输入单输出 文章目录 一、基本原理1. 数据预处理2. PSO优化&#xff08;粒子群优化&#xff09;3. KELM训练&#xff08;核极限学习机&#xff09;4. AdaBoost集成5. 模型评估和优化6.…
阅读更多...
【C语言】深入理解指针（四）qsort函数的实现

【C语言】深入理解指针（四）qsort函数的实现

指针4 1.回调函数是什么2.qsort使用举例3.qsort函数的模拟实现 1.回调函数是什么 回调函数就是⼀个通过函数指针调⽤的函数。 如果你把函数的指针&#xff08;地址&#xff09;作为参数传递给另⼀个函数&#xff0c;当这个指针被⽤来调⽤其所指向的函数 时&#xff0c;被调⽤的…
阅读更多...
C语言初阶 --- 数据在内存中的存储

C语言初阶 --- 数据在内存中的存储

&#x1f388; 个人主页&#x1f449;&#xff1a;tbRNA-CSDN博客 &#x1f4af; 个人简介&#xff1a;在校大学生一枚&#x1f48b;. &#x1f60d; 希望我的文章对大家有着不一样的帮助&#xff0c;欢迎大家关注我&#xff0c;感谢大家的多多支持&#xff01; &#x1f389; …
阅读更多...
【ragflow】安装2：源码安装依赖

【ragflow】安装2：源码安装依赖

中文文档【ragflow】安装1： docker：失败官方说的成功 docker 安装的启动失败 重新来一遍，不会重新拉取： root@k8s-master-pfsrv:/home/zhangbin/perfwork/rag# cd ragflow/ root@k8s-master-pfsrv:/home/
阅读更多...
互联网应用主流框架整合之Spring缓存机制和Redis结合

互联网应用主流框架整合之Spring缓存机制和Redis结合

Redis和数据库的结合 在实际的商用软件使用中，通常都是Redis和关系型数据配置使用，单纯使用Redis来存数据成本太高，并且其持久化和计算能力偏差，这两块无法和关系型数据相比较，而Redis和关系型数据库共存的场景就会带来另一个问题，就是在两者之间的数据一致性的问题，有…
阅读更多...
Electron 项目实战 02：打包和自动更新

Electron 项目实战 02：打包和自动更新

技术选型 electron-forgeelectron-builder electron-forge 是Electron 官方文档介绍的&#xff0c;打包和发布都包含了&#xff0c;但是包含的坑也非常多。electron-builder下载量和集成打包非常顺利&#xff0c;本教程也是采用electron-buid来介绍打包。大家在技术选型的时候…
阅读更多...
RabbitMQ练习（Routing）

RabbitMQ练习（Routing）

1、RabbitMQ教程 《RabbitMQ Tutorials》https://www.rabbitmq.com/tutorials 2、环境准备 参考&#xff1a;《RabbitMQ练习&#xff08;Hello World&#xff09;》和《RabbitMQ练习&#xff08;Work Queues&#xff09;》。 确保RabbitMQ、Sender、Receiver、Receiver2容器…
阅读更多...
ip地址变化是什么意思？手机地址ip一直变化怎么办

ip地址变化是什么意思？手机地址ip一直变化怎么办

IP地址作为互联网设备的唯一标识&#xff0c;‌其稳定性对于网络连接至关重要。‌然而&#xff0c;‌手机IP地址频繁变动可能带来一系列问题。‌本文将深入探讨IP地址变化的含义、‌IP地址频繁变动的原因&#xff0c;‌以及提供手机地址IP一直变化的有效应对策略。‌ 一、IP地址…
阅读更多...
LLaMA-Factory微调入门个人重制版

LLaMA-Factory微调入门个人重制版

LLaMA-Factory微调入门个人重制版 说明&#xff1a; 首次发表日期&#xff1a;2024-08-30LLaMA-Factory 官方Github仓库&#xff1a; https://github.com/hiyouga/LLaMA-Factory 关于 本文是对LLaMA-Factory入门教程 https://zhuanlan.zhihu.com/p/695287607 的个人重制版&…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站