数据结构C语言描述3(图文结合)--双链表、循环链表、约瑟夫环问题

前言

  • 这个专栏将会用纯C实现常用的数据结构和简单的算法；
  • 有C基础即可跟着学习，代码均可运行；
  • 准备考研的也可跟着写，个人感觉，如果时间充裕，手写一遍比看书、刷题管用很多，这也是本人采用纯C语言实现的原因之一；
  • 欢迎收藏 + 关注，本人将会持续更新。

文章目录

  • 双向链表
    • 简介
    • 双链表实现
  • 循环链表
  • 循环链表约瑟夫环问题

双向链表

简介

🚡 双向链表，对比单链表来说，顾名思义，就是指向指向有两个指针，指向前后节点。

🌾 结合单链表，单链表有无头和有头之分，双向链表也是一样，这里是无头双链表，采用再封装写法，不是二级指针写法，再封装写法比较写起来比较容易，个人比较偏爱🤠🤠🤠🤠

双链表图示：

在这里插入图片描述

🉑 从ADT抽象中来说：

总结起来一句话：增删改查，🤠🤠🤠，假设双向链表是一个结合，这这个结合功能有：

  • 增加元素
  • 删除元素
  • 拿取元素
  • 查询元素
  • 修改元素
  • …………………………

双链表实现

这里采用再封装的方法，实现无头链表，有头和无头再单链表的那一节以及讲过了，这里采用无头实现

💠 节点封装

在双链表中，对于每一个节点来说，都有一个指向前、指向后节点的指针。

typedef int DataType;typedef struct Node {DataType data;struct Node* prev;  // 前struct Node* next;   // 后
}Node;

⚜️ 链表封装

这一步封装的作用是，可以更好的操作链表的一些操作，这个size的一个再封装写法的核心，无头与有头再实现的过程中，核心就在于第一个头节点的处理，无头如果没有任何节点，则插入的节点则作为第一个节点，但是这样会改变指针的指向，这也是因为需要传递二级指针的原因，而再封装写法则很好的解决了这个问题。

typedef struct List {Node* headNode;Node* tailNode;int size;
}List;

🍨 创建节点

采用calloc创建节点，这样可以自动赋值为0。

Node* create_node(DataType data)
{Node* node = (Node*)calloc(1, sizeof(Node));assert(node);node->data = data;return node;
}

🍤 创建链表

List* create_list()
{List* list = (List*)calloc(1, sizeof(List));assert(list);return list;
}

🤕 插入–头插

  • 情况判断：是否为空链表
    • 空链表：插件节点，作为头
    • 不为空：头插，如图：
void push_front(List* list, DataType data)
{if (list == NULL) {return;}Node* node = create_node(data);if (list->size == 0) {    // 这种写法的优势，不用传递二级指针list->tailNode = node;}else {node->next = list->headNode;list->headNode->prev = node;}list->headNode = node;list->size++;
}

🌮 插入–尾插入

  • 情况判断：是否为空链表
    • 为空：插入，作为头
    • 不为空：找到尾节点，插入
void push_back(List* list, DataType data)
{if (list == NULL) {return;}Node* node = create_node(data);if (list->size == 0) {list->headNode = node;}else {list->tailNode->next = node;node->prev = list->tailNode;}list->tailNode = node;list->size++;
}

💠 插入–任意位置

  • 规则： 在元素后位置插入
  • 情况：3种
    • 没有该元素
    • 尾插
    • 任意插
void insert(List* list, DataType posData, DataType data)
{if (list == NULL || list->size == 0) {  // size ！= 0 保证有头return;}Node* t = list->headNode;while (t->next != NULL && t->data != posData) {t = t->next;}if (t->data != posData) {   // 没有该元素return;}else if (t->next == NULL && t->data == posData) {  // 尾插Node* node = create_node(data);node->prev = t;t->next = node;list->tailNode = node;   // 尾巴移位}else{Node* node = create_node(data);node->next = t->next;t->next->prev = node;node->prev = t;t->next = node;}list->size++;
}

🎧 删除–头删

注意点：释放后指针指向问题：

  • 如果说就一个元素，则删除后，在封装头需要指向NULL
  • 如果不是，则下一个元素的prev指针需要赋值为NULL
void pop_front(List* list)
{if (list == NULL || list->size == 0) {return;}Node* node = list->headNode;list->headNode = node->next;free(node);(list->headNode) ? (list->headNode->prev = NULL) : (list->tailNode = NULL); // 判断是否只有一个节点的情况node = NULL;
}

🚖 删除–尾删除

注意点：释放后指针指向问题：

  • 如果说就一个元素，则删除后，在封装头需要指向NULL
  • 如果不是，则上一个元素的next指针需要赋值为NULL
void pop_back(List* list)
{if (list == NULL || list->size == 0) {return;}Node* node = list->tailNode;list->tailNode = list->tailNode->prev;free(node);(list->tailNode) ? (list->tailNode->next = NULL) : (list->headNode = NULL);list->size--;
}

🦅 删除–任意位置删除

四种情况：

  • 没有找到
  • 找到了
    • 头删
    • 尾删
    • 任意位置删
void erase(List* list, DataType posData)
{if (list == NULL || list->size == 0) {return;}Node* cur = list->headNode;while (cur->next != NULL && cur->data != posData) {cur = cur->next;}// 没有找到if (cur->data != posData) {return;}else if (cur->next == NULL) {   // 尾删除pop_back(list);}else if (cur->prev == NULL) {   // 头删pop_front(list);}else {Node* t = cur;cur->prev->next = cur->next;cur->next->prev = cur->prev;free(t);t = NULL;list->size--;}
}

🌐 万金油函数

bool empty(List* list)
{if (list == NULL) {return true;}return list->size == 0;
}size_t size(List* list)
{if (list == NULL) {return 0;}return list->size;
}

📤 向前遍历

void travel_front(List* list)
{if (list == NULL) {return;}Node* cur = list->headNode;while (cur) {printf("%d ", cur->data);cur = cur->next;}printf("\n");
}

🎉 向后遍历

void travel_back(List* list)
{if (list == NULL) {return;}Node* cur = list->tailNode;while (cur) {printf("%d ", cur->data);cur = cur->prev;}printf("\n");
}

⏰ 总代码

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>typedef int DataType;typedef struct Node {DataType data;struct Node* prev;struct Node* next;
}Node;typedef struct List {Node* headNode;Node* tailNode;int size;
}List;Node* create_node(DataType data)
{Node* node = (Node*)calloc(1, sizeof(Node));assert(node);node->data = data;return node;
}List* create_list()
{List* list = (List*)calloc(1, sizeof(List));assert(list);return list;
}void push_front(List* list, DataType data)
{if (list == NULL) {return;}Node* node = create_node(data);if (list->size == 0) {list->tailNode = node;}else {node->next = list->headNode;list->headNode->prev = node;}list->headNode = node;list->size++;
}void push_back(List* list, DataType data)
{if (list == NULL) {return;}Node* node = create_node(data);if (list->size == 0) {list->headNode = node;}else {list->tailNode->next = node;node->prev = list->tailNode;}list->tailNode = node;list->size++;
}void insert(List* list, DataType posData, DataType data)
{if (list == NULL || list->size == 0) {  // size ！= 0 保证有头return;}Node* t = list->headNode;while (t->next != NULL && t->data != posData) {t = t->next;}if (t->data != posData) {   // 没有该元素return;}else if (t->next == NULL && t->data == posData) {  // 尾插Node* node = create_node(data);node->prev = t;t->next = node;list->tailNode = node;   // 尾巴移位}else{Node* node = create_node(data);node->next = t->next;t->next->prev = node;node->prev = t;t->next = node;}list->size++;
}void pop_front(List* list)
{if (list == NULL || list->size == 0) {return;}Node* node = list->headNode;list->headNode = node->next;free(node);(list->headNode) ? (list->headNode->prev = NULL) : (list->tailNode = NULL); // 判断是否只有一个节点的情况node = NULL;
}void pop_back(List* list)
{if (list == NULL || list->size == 0) {return;}Node* node = list->tailNode;list->tailNode = list->tailNode->prev;free(node);(list->tailNode) ? (list->tailNode->next = NULL) : (list->headNode = NULL);list->size--;
}void erase(List* list, DataType posData)
{if (list == NULL || list->size == 0) {return;}Node* cur = list->headNode;while (cur->next != NULL && cur->data != posData) {cur = cur->next;}// 没有找到if (cur->data != posData) {return;}else if (cur->next == NULL) {   // 尾删除pop_back(list);}else if (cur->prev == NULL) {   // 头删pop_front(list);}else {Node* t = cur;cur->prev->next = cur->next;cur->next->prev = cur->prev;free(t);t = NULL;list->size--;}
}bool empty(List* list)
{if (list == NULL) {return true;}return list->size == 0;
}size_t size(List* list)
{if (list == NULL) {return 0;}return list->size;
}void travel_front(List* list)
{if (list == NULL) {return;}Node* cur = list->headNode;while (cur) {printf("%d ", cur->data);cur = cur->next;}printf("\n");
}void travel_back(List* list)
{if (list == NULL) {return;}Node* cur = list->tailNode;while (cur) {printf("%d ", cur->data);cur = cur->prev;}printf("\n");
}int main()
{List* list = create_list();for (int i = 1; i < 4; i++) {push_front(list, i);}for (int i = 1; i < 4; i++) {push_back(list, i * 10);}travel_front(list);travel_back(list);insert(list, 3, 33);insert(list, 30, 300);travel_front(list);travel_back(list);pop_front(list);travel_front(list);travel_back(list);pop_back(list);travel_front(list);travel_back(list);erase(list, 33);erase(list, 30);erase(list, 10);travel_front(list);travel_back(list);return 0;
}

循环链表

循环链表分为循环单链表，循环双链表，单链表和双链表又分为有头和无头链表，这里是有头循环双链表。

双向循环链表（Doubly Circular Linked List）是一种数据结构，其中每个节点都包含两个指针，一个指向前一个节点，一个指向后一个节点。与普通链表不同的是，双向循环链表的最后一个节点的下一个指针指向头节点，而头节点的前一个指针指向最后一个节点，形成一个循环。

在这里插入图片描述

🤕 节点封装

typedef int DataType;typedef struct Node {DataType data;struct Node* prev;struct Node* next;
}Node;

🍨 创建节点

Node* create_node(DataType data) 
{Node* node = (Node*)calloc(1, sizeof(Node));assert(node);node->data = data;return node;
}

⚜️ 创建链表

这里需要构建一个循环节点(链表)，如图：

在这里插入图片描述

Node* create_list()
{Node* list = (Node*)calloc(1, sizeof(Node));assert(list);list->next = list;list->prev = list;return list;
}

🎧 插入–头插

双向头删就很容易了，如图：

在这里插入图片描述

void push_front(Node* list, DataType data)
{assert(list);Node* node = create_node(data);node->next = list->next;list->next->prev = node;   // 难点，不用担心 next，prev为空的时候node->prev = list;list->next = node;
}

🌮 插入–尾插

尾巴删除也很容易，因为头和尾巴互相找到，如图：

在这里插入图片描述

void push_back(Node* list, DataType data)
{assert(list);Node* node = create_node(data);node->prev = list->prev;list->prev->next = node;node->next = list;list->prev = node;
}

⛹️‍♀️ 插入–任意位置

任意位置也不难，找到要插入的位置，要注意的是找不到的情况。

// 找到要插入那个节点的位置节点
void insert(Node* list, DataType posData ,DataType data)
{assert(list);Node* cur = list->next;while (cur->next != list && cur->data != posData) {cur = cur->next;}if (cur->data != posData) {   // 思考，为什么不能 cur->next != list ?????return;}else {Node* node = create_node(data);node->next = cur->next;cur->next->prev = node;node->prev = cur;cur->next = node;}}

👟 删除–头删

注意： 一个节点的头节点指向不同。

两种情况：

  1. 如果一个元素，这个时候删除，头节点指向修改和两个元素以上删除不同，这个时候头节点需要指向自己
  2. 两个元素及上
void pop_front(Node* list)
{assert(list);Node* cur = list->next;if (cur == list) {   // 无节点return;}else if(cur->next == list) {   // 一个节点list->prev = list;list->next = list;}else {list->next = cur->next;   // 两个节点以上cur->next->prev = list;}free(cur);cur = NULL;
}

📑 删除–尾删

这个也是简单的，因为可以通过头节点直接找到尾节点，这个时候就只需要一种情况即可，因为创建双链表有一个很好的特性，

void pop_back(Node* list)
{assert(list);Node* cur = list->prev;   // 因为可以获取尾节点if (cur == list) {return;}else {cur->prev->next = list;   // 哪怕是一个节点，也和普通情况也是一样list->prev = cur->prev;   // 这个也是一样，free(cur);cur = NULL;}}

🚴‍♀ 删除–任意位置

很简单，因为这个也不用记录前驱节点，也不用找尾节点了，只需要考虑两种情况：

  1. 没有找到
  2. 找到了
void erase(Node* list, DataType posData)
{assert(list);Node* cur = list->next;while (cur->next != list && cur->data != posData) {cur = cur->next;}if (cur->data != posData) {return;}else {cur->prev->next = cur->next;cur->next->prev = cur->prev;free(cur);cur = NULL;}
}

🔱 遍历

void travel_front(Node* list)
{assert(list);Node* cur = list->next;while (cur != list) {printf("%d ", cur->data);cur = cur->next;}printf("\n");
}void travel_back(Node* list)
{assert(list);Node* cur = list->prev;while (cur != list) {printf("%d ", cur->data);cur = cur->prev;}printf("\n");
}

⚗️ 总代码

#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>// 有头链表实现，简单点typedef int DataType;typedef struct Node {DataType data;struct Node* prev;struct Node* next;
}Node;Node* create_node(DataType data) 
{Node* node = (Node*)calloc(1, sizeof(Node));assert(node);node->data = data;return node;
}Node* create_list()
{Node* list = (Node*)calloc(1, sizeof(Node));assert(list);list->next = list;list->prev = list;return list;
}void push_front(Node* list, DataType data)
{assert(list);Node* node = create_node(data);node->next = list->next;list->next->prev = node;   // 难点，不用担心 next，prev为空的时候node->prev = list;list->next = node;
}void push_back(Node* list, DataType data)
{assert(list);Node* node = create_node(data);node->prev = list->prev;list->prev->next = node;node->next = list;list->prev = node;
}
// 找到要插入那个节点的位置节点
void insert(Node* list, DataType posData ,DataType data)
{assert(list);Node* cur = list->next;while (cur->next != list && cur->data != posData) {cur = cur->next;}if (cur->data != posData) {   // 思考，为什么不能 cur->next != list ?????return;}else {Node* node = create_node(data);node->next = cur->next;cur->next->prev = node;node->prev = cur;cur->next = node;}}void pop_front(Node* list)
{assert(list);Node* cur = list->next;if (cur == list) {return;}else if(cur->next == list) {list->prev = list;list->next = list;}else {list->next = cur->next;cur->next->prev = list;}free(cur);cur = NULL;
}void pop_back(Node* list)
{assert(list);Node* cur = list->prev;if (cur == list) {return;}else {cur->prev->next = list;list->prev = cur->prev;free(cur);cur = NULL;}}void erase(Node* list, DataType posData)
{assert(list);Node* cur = list->next;while (cur->next != list && cur->data != posData) {cur = cur->next;}if (cur->data != posData) {return;}else {cur->prev->next = cur->next;cur->next->prev = cur->prev;free(cur);cur = NULL;}
}void travel_front(Node* list)
{assert(list);Node* cur = list->next;while (cur != list) {printf("%d ", cur->data);cur = cur->next;}printf("\n");
}void travel_back(Node* list)
{assert(list);Node* cur = list->prev;while (cur != list) {printf("%d ", cur->data);cur = cur->prev;}printf("\n");
}int main()
{Node* list = create_list();push_front(list, 1);push_front(list, 2);push_front(list, 3);travel_front(list);travel_back(list);push_back(list, 11);push_back(list, 22);push_back(list, 33);travel_front(list);travel_back(list);insert(list, 2, 20);insert(list, 3, 30);insert(list, 33, 330);travel_front(list);travel_back(list);pop_front(list);travel_front(list);travel_back(list);pop_back(list);travel_front(list);travel_back(list);erase(list, 33);travel_front(list);travel_back(list);return 0;
}

循环链表约瑟夫环问题

讲一个比较有意思的故事：约瑟夫是犹太军队的一个将军，在反抗罗马的起义中，他所率领的军队被击溃，只剩下残余的部队40余人，他们都是宁死不屈的人，所以不愿投降做叛徒。一群人表决说要死，所以用一种策略来先后kill所有人。
于是约瑟夫建议：每次由其他两人一起kill一个人，而被kill的人的先后顺序是由抽签决定的，约瑟夫有预谋地抽到了最后一签，在kill了除了他和剩余那个人之外的最后一人，他劝服了另外一个没死的人投降了罗马。

我们这个规则是这么定的：

  • 在一间房间总共有n个人（下标0～n-1），只能有最后一个人活命。
  • 按照如下规则去排除人：
    • 所有人围成一圈
    • 顺时针报数，每次报到q的人将被排除掉
    • 被排除掉的人将从房间内被移走
    • 然后从被kill掉的下一个人重新报数，继续报q，再清除，直到剩余一人
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>/*
* 用上一个链表，也可以。这里采用无头循环双链表实现
* 无头采用再次封装的写法
*/typedef struct Node {int data;struct Node* prev;struct Node* next;
}Node;typedef struct List {Node* headNode;
}List;// 每一个节点创建都是循环
Node* create_node(int data)
{Node* node = (Node*)calloc(1, sizeof(Node));assert(node);node->data = data;node->prev = node;node->next = node;return node;
}void push_back(List* list, int data)
{assert(list);Node* node = create_node(data);if (list->headNode == NULL) {list->headNode = node;}else {Node* cur = list->headNode->prev;node->next = list->headNode;list->headNode->prev = node;cur->next = node;node->prev = cur;}
}void erase(List* list, Node* node)
{assert(list);assert(node);// 一个节点if (node->next == node) {free(node);node = NULL;list->headNode = NULL;}else {node->prev->next = node->next;node->next->prev = node->prev;if (list->headNode == node) {   // 防止删除头list->headNode = node->next;}free(node);node = NULL;}
}void travel(List* list)
{Node* cur = list->headNode;while (cur->next != list->headNode) {printf("%d ", cur->data);cur = cur->next;}printf("%d ", cur->data);printf("\n");
}// 只做演示，不考虑内存问题
void game_run(int n, int m)
{if (n < 0 || m < 0) {return;}List list = { NULL };for (int i = 1; i <= n; i++) {push_back(&list, i);}travel(&list);Node* cur = list.headNode;while (n > 1) {// 报数for (int i = 1; i < m; i++) {cur = cur->next;}Node* next = cur->next;erase(&list, cur);// 重置报数cur = next;n--;}printf("天选之子: %d\n", cur->data);
}int main()
{game_run(10, 3);return 0;
}

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

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

相关文章

设计模式-策略模式

设计模式-策略模式

1. 策略模式 策略模式&#xff08;Strategy Pattern&#xff09;针对一组算法&#xff0c;将每一个算法封装到 具有共同接口 的独立的类中&#xff0c;从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。 在软件开发中&#xff0c;经常会遇到…
阅读更多...
FFmpeg 4.3 音视频-多路H265监控录放C++开发十四，总结编码过程，从摄像头获得数据后，转成AVFrame，然后再次转成AVPacket，

FFmpeg 4.3 音视频-多路H265监控录放C++开发十四，总结编码过程，从摄像头获得数据后，转成AVFrame，然后再次转成AVPacket，

也就是将摄像头采集到的YUV 的数据换成 AVFrame&#xff0c;然后再次转成 AVPacket&#xff0c;那么这AVPakcet数据要怎么办呢&#xff1f;分为三种情况&#xff1a; 一种是将AVPacket存储成h264文件&#xff0c;由于h264编码器在将avframe变成avpacket的时候就是按照h264的格…
阅读更多...
【srm，招标询价】采购电子化全流程，供应商准入审核，在线询价流程管理（JAVA+Vue+mysql）

【srm，招标询价】采购电子化全流程，供应商准入审核，在线询价流程管理（JAVA+Vue+mysql）

前言&#xff1a; 随着互联网和数字技术的不断发展&#xff0c;企业采购管理逐渐走向数字化和智能化。数字化采购平台作为企业采购管理的新模式&#xff0c;能够提高采购效率、降低采购成本、优化供应商合作效率&#xff0c;已成为企业实现效益提升的关键手段。系统获取在文末…
阅读更多...
Transformer学习笔记（一）

Transformer学习笔记（一）

Transformer学习笔记 基于 3B1B 可视化视频 自注意力机制 1.每个词的初始嵌入是一个高维向量&#xff0c;只编码该单词含义&#xff0c;与上下文没有关联 2.对初始向量进行位置编码&#xff0c;在高维向量中编码进位置信息&#xff08;单词在语言序列中的位置信息&#xff…
阅读更多...
4.4.5 timer中断流向Linux（从interrupt log回放）

4.4.5 timer中断流向Linux（从interrupt log回放）

4.4.5 timer中断流向Linux&#xff08;从interrupt log回放&#xff09; 按上文所述&#xff0c;timer中断3已经记录到root domain的interrupt log。在《3.4.1.3 IPIPE interrupt log数据结构》中&#xff0c;已经讨论过interrupt log的记录与回放。本小结&#xff0c;讨论什么…
阅读更多...
WinDefender Weaker

WinDefender Weaker

PPL Windows Vista / Server 2008引入 了受保护进程的概念&#xff0c;其目的不是保护您的数据或凭据。其最初目标是保护媒体内容并符合DRM &#xff08;数字版权管理&#xff09;要求。Microsoft开发了此机制&#xff0c;以便您的媒体播放器可以读取例如蓝光&#xff0c;同时…
阅读更多...
基于redis完成延迟队列

基于redis完成延迟队列

添加依赖 使用redisson完成延迟队列效果 <!-- redisson依赖 --><dependency><groupId>org.redisson</groupId><artifactId>redisson</artifactId><version>3.17.4</version> <!-- 请使用最新版本 --></dependency&g…
阅读更多...
星辰资讯 | TiDB v7.5.4 v8.4.0 发版

星辰资讯 | TiDB v7.5.4 v8.4.0 发版

作者&#xff1a; ShawnYan 原文来源&#xff1a; https://tidb.net/blog/6e299751 TiDB 8.4.0 DMR 发版 11 月 11 日&#xff0c;TiDB 8.4.0 版本发布&#xff0c;以下是该版本的一些关键特性和改进&#xff1a; 性能 分区表全局索引成为正式功能 &#xff1a;提高检索…
阅读更多...
Spring基础

Spring基础

Spring基础 目录&#xff1a; 一、Spring框架简介 二、Spring容器机制 一、Spring框架简介 1. Spring发展历程 •在Spring兴起之前&#xff0c;Java企业级开发主要通过EJB (Enterprise JavaBean)完成。EJB是服务器端的组件模型&#xff0c;由于它过于依靠EJB容器&#xf…
阅读更多...
二分查找法(leetcode 704)

二分查找法(leetcode 704)

在一个数组里找一个target&#xff0c;判断这个target在不在这个数组里&#xff0c;如果在&#xff0c;返回这个数组所对应的这个元素所对应的下标&#xff0c;否则返回-1. 易错点&#xff1a; &#xff08;1&#xff09;while(left<right) vs while(left<…
阅读更多...
python的matplotlib实现数据分析绘图

python的matplotlib实现数据分析绘图

目录 需求 效果 数据分析绘图示例 代码解释 运行结果 需求 分析一个班级中学生成绩分布&#xff0c;并绘图 效果 数据分析绘图示例 import matplotlib.pyplot as plt import numpy as np# 假设的学生成绩数据 np.random.seed(0) # 设置随机种子以确保结果可复现 score…
阅读更多...
STM32电源管理—实现低功耗

STM32电源管理—实现低功耗

注&#xff1a; 本文是学习野火的指南针开发板过程的学习笔记&#xff0c;可能有误&#xff0c;详细请看B站野火官方配套视频教程&#xff08;这个教程真的讲的很详细&#xff0c;请给官方三连吧&#xff09; 在响应绿色发展的同时&#xff0c;在很多应用场合中都对电子设备的功…
阅读更多...
[JAVA]MyBatis框架—如何获取SqlSession对象实现数据交互（基础篇）

[JAVA]MyBatis框架—如何获取SqlSession对象实现数据交互（基础篇）

假设我们要查询数据库的用户信息&#xff0c;在MyBatis框架中&#xff0c;首先需要通过SqlSessionFactory创建SqlSession&#xff0c;然后才能使用SqlSession获取对应的Mapper接口&#xff0c;进而执行查询操作 在前一章我们学习了如何创建MyBatis的配置文件mybatis.config.xm…
阅读更多...
【视频讲解】Python深度神经网络DNNs-K-Means（K-均值）聚类方法在MNIST等数据可视化对比分析...

【视频讲解】Python深度神经网络DNNs-K-Means（K-均值）聚类方法在MNIST等数据可视化对比分析...

全文链接&#xff1a;https://tecdat.cn/?p38289 分析师&#xff1a;Cucu Sun 近年来&#xff0c;由于诸如自动编码器等深度神经网络&#xff08;DNN&#xff09;的高表示能力&#xff0c;深度聚类方法发展迅速。其核心思想是表示学习和聚类可以相互促进&#xff1a;好的表示会…
阅读更多...
Java 网络编程（二）—— TCP流套接字编程

Java 网络编程（二）—— TCP流套接字编程

TCP 和 UDP 的区别 在传输层&#xff0c;TCP 协议是有连接的&#xff0c;可靠传输&#xff0c;面向字节流&#xff0c;全双工 而UDP 协议是无连接的&#xff0c;不可靠传输&#xff0c;面向数据报&#xff0c;全双工 有连接和无连接的区别是在进行网络通信的时候&#xff0c;…
阅读更多...
机器学习—正则化和偏差或方差

机器学习—正则化和偏差或方差

正则化参数的选择对偏差和方差的影响 用一个四阶多项式&#xff0c;要用正则化拟合这个模型&#xff0c;这里的lambda的值是正则化参数&#xff0c;它控制着你交易的金额&#xff0c;保持参数w与训练数据拟合&#xff0c;从将lambda设置为非常大的值的示例开始&#xff0c;例如…
阅读更多...
【笔记】企业架构TOGAF 10的架构从4A增加至6A

【笔记】企业架构TOGAF 10的架构从4A增加至6A

背景 谈谈学习TOGAF 10的总结和笔记&#xff0c;说说较9.2版本有哪些变化。最直观的当属从原来的4A架构升级到6A架构&#xff0c;单独从原来的4A中提炼形成了安全架构、系统架构两个概念&#xff0c;谈谈理解并回顾总结一下学习笔记。 TOGAF 10 将安全架构单独列为一种架构&…
阅读更多...
AI写作（十）发展趋势与展望（10/10）

AI写作（十）发展趋势与展望（10/10）

一、AI 写作的崛起之势 在当今科技飞速发展的时代&#xff0c;AI 写作如同一颗耀眼的新星&#xff0c;迅速崛起并在多个领域展现出强大的力量。 随着人工智能技术的不断进步&#xff0c;AI 写作在内容创作领域发挥着越来越重要的作用。据统计&#xff0c;目前已有众多企业开始…
阅读更多...
【模块一】kubernetes容器编排进阶实战之资源管理核心概念

【模块一】kubernetes容器编排进阶实战之资源管理核心概念

kubernetes 资源管理核心概念 k8s的设计理念—分层架构 CRI-container runtime interface-容器运行接口 CNI-container network interface-容器网络接口 CSI-container storage interface-容器存储接口 k8s的设计理念—API设计原则 https://www.kubernetes.org.cn/kubernete…
阅读更多...
DBeaver中PostgreSQL数据库显示不全的解决方法

DBeaver中PostgreSQL数据库显示不全的解决方法

本文介绍在DBeaver中&#xff0c;连接PostgreSQL后&#xff0c;数据库显示不全的解决方法。 最近&#xff0c;在DBeaver中连接了本地的PostgreSQL数据库。但是连接后打开这个数据库时发现&#xff0c;其所显示的Databases不全。如下图所示&#xff0c;Databases只显示了一个pos…
阅读更多...
最新文章

Copyright @ 2022~2023