【算法】查找与排序

因文章篇幅有限，查找和排序分开写（附代码与详细过程 + 注释详解），这篇文章主讲算法中的数据查找。

查找是数据结构中最基本的操作之一，用于从给定的数据集合中找到特定的目标数据。查找的效率直接影响程序的性能，选择合适的查找方法取决于数据的组织形式和应用场景。

查找的分类

查找操作可以按照数据存储结构和应用场景分为以下几类：

  1. 线性表上的查找
    • 顺序查找（线性查找）
    • 二分查找（折半查找）
    • 索引查找（分块查找）
  2. 树上的查找
    • 二叉搜索树查找
    • 平衡二叉树查找（如 AVL 树、红黑树）
    • B 树和 B+ 树查找
  3. 散列表上的查找
    • 基于哈希表的查找（hash查找）
  4. 图的查找
    • 广度优先搜索（BFS）
    • 深度优先搜索（DFS）
线性表上的查找
1. 顺序查找（线性查找）

逐一扫描线性表中的元素，直到找到目标值或扫描完所有元素。适用于无序集合。

时间复杂度

  • 最好情况：O(1)（目标值在第一个位置）。
  • 最坏情况：O(n)（目标值不在表中）。
  • 平均情况：O(n/2) ≈ O(n)。
int linearSearch(int arr[], int n, int target) {for (int i = 0; i < n; i++) {if (arr[i] == target) {return i;  // 找到并返回索引}}return -1;  // 未找到
}
// 适用场景
//   数据无序。
//   数据规模小，查找次数少。
2. 二分查找（折半查找）

在有序集合中，每次将查找范围缩小一半，直至找到目标值。适用于静态有序集合。

时间复杂度

  • 最好情况：O(1)。
  • 最坏情况：O(log n)。
  • 平均情况：O(log n)。
int half_search(int *a,int elem)
{int low,high,mid; //设置三个指向标志位low=0;     //低位下标high=N-1;  //高位下标while(low<=high)  //当low>high 表中没有对应数据{mid=(low+high)/2;  //不断进行操作的中间下标if(elem>a[mid])  //要查的数据与中间下标指向的值做比较{low=mid+1;   //大于mid指向值时，低位下标指向位置改变}if(elem<a[mid]) //小于mid指向值时，高位下标指向位置改变{high=mid-1;}if(elem==a[mid]) //等于中间值时{return mid+1; //返回的是排在数组中第几个}}return -1; // 未找到
}
// 适用场景
//   数据有序。
//   需要频繁查找。
3. 索引查找（分块查找）

将线性表划分为多个块，块内元素无序，但块间有序。通过索引表定位块，再在块内使用顺序查找。

时间复杂度

  • 查找索引表：O(√n)。
  • 块内顺序查找：O(√n)。
  • 总复杂度：O(2√n) ≈ O(√n)。
int blockSearch(int index[], int blocks[][10], int indexSize, int blockSize, int target) {int block = -1;// 查找索引表for (int i = 0; i < indexSize; i++) {if (target <= index[i]) {block = i;break;}}if (block == -1) return -1;  // 未找到// 在对应的块中顺序查找for (int j = 0; j < blockSize; j++) {if (blocks[block][j] == target) {return block * blockSize + j;  // 返回全局索引}}return -1;  // 未找到
}
// 适用场景
//   数据量大，且对查找效率要求较高。
//   索引表占用空间较小。
树上的查找
1. 二叉搜索树查找

在二叉搜索树中，每个节点的左子树节点值小于根节点值，右子树节点值大于根节点值。查找时，根据节点值大小递归向左或右子树查找。

时间复杂度

  • 平衡树：O(log n)。
  • 退化为链表时：O(n)。
Node* search(Node* root, int key) {if (root == NULL || root->data == key) {return root;  // 找到目标值或未找到}if (key < root->data) {return search(root->left, key);  // 左子树查找}return search(root->right, key);    // 右子树查找
}
// 适用场景
//   动态数据集合。
//   数据插入和删除频繁。
2. 平衡二叉树查找

平衡二叉树（如 AVL 树、红黑树）通过平衡旋转维持树的高度在 O(log n)。查找操作与二叉搜索树类似。

时间复杂度

  • O(log n)。
#include <stdio.h>
#include <stdlib.h>// 定义 AVL 树节点
typedef struct Node {int data;               // 节点值struct Node* left;      // 左子树struct Node* right;     // 右子树int height;             // 节点高度
} Node;// 创建新节点
Node* createNode(int data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->left = NULL;newNode->right = NULL;newNode->height = 1;  // 新节点高度为 1return newNode;
}// 适用场景
//   动态数据集合，要求查找性能稳定。
3. B 树和 B+ 树查找

B 树是一种多叉平衡树，适用于外部存储（如磁盘）。B+ 树是 B 树的改进版本，叶子节点通过链表连接，适合范围查找。

时间复杂度

  • O(log n)。
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>#define MAX_KEYS 3  // B 树的阶数为 4（MAX_KEYS + 1）// B 树的查找过程
// B 树节点定义
typedef struct BTreeNode {int keys[MAX_KEYS];               // 节点中的关键字struct BTreeNode* children[MAX_KEYS + 1];  // 子节点指针int keyCount;                     // 当前节点的关键字数量bool isLeaf;                      // 是否是叶子节点
} BTreeNode;// 创建 B 树节点
BTreeNode* createNode(bool isLeaf) {BTreeNode* newNode = (BTreeNode*)malloc(sizeof(BTreeNode));newNode->isLeaf = isLeaf;newNode->keyCount = 0;for (int i = 0; i <= MAX_KEYS; i++) {newNode->children[i] = NULL;}return newNode;
}// 查找关键字
BTreeNode* search(BTreeNode* root, int key) {if (root == NULL) return NULL;int i = 0;// 在当前节点中查找关键字while (i < root->keyCount && key > root->keys[i]) {i++;}// 如果找到关键字，返回当前节点if (i < root->keyCount && key == root->keys[i]) {return root;}// 如果是叶子节点，说明找不到if (root->isLeaf) {return NULL;}// 否则递归到对应的子节点return search(root->children[i], key);
}// 插入关键字到非满节点
void insertNonFull(BTreeNode* node, int key) {int i = node->keyCount - 1;// 如果是叶子节点if (node->isLeaf) {// 插入到合适的位置while (i >= 0 && node->keys[i] > key) {node->keys[i + 1] = node->keys[i];i--;}node->keys[i + 1] = key;node->keyCount++;} else {// 如果是内部节点while (i >= 0 && node->keys[i] > key) {i--;}i++;// 如果子节点已满，先分裂if (node->children[i]->keyCount == MAX_KEYS) {splitChild(node, i);if (key > node->keys[i]) {i++;}}// 递归插入到子节点insertNonFull(node->children[i], key);}
}// 分裂子节点
void splitChild(BTreeNode* parent, int index) {BTreeNode* child = parent->children[index];BTreeNode* newChild = createNode(child->isLeaf);newChild->keyCount = MAX_KEYS / 2;// 将后半部分的关键字复制到新节点for (int i = 0; i < MAX_KEYS / 2; i++) {newChild->keys[i] = child->keys[i + MAX_KEYS / 2 + 1];}// 如果不是叶子节点，将子节点指针也复制if (!child->isLeaf) {for (int i = 0; i <= MAX_KEYS / 2; i++) {newChild->children[i] = child->children[i + MAX_KEYS / 2 + 1];}}child->keyCount = MAX_KEYS / 2;// 将新节点插入到父节点for (int i = parent->keyCount; i > index; i--) {parent->children[i + 1] = parent->children[i];parent->keys[i] = parent->keys[i - 1];}parent->children[index + 1] = newChild;parent->keys[index] = child->keys[MAX_KEYS / 2];parent->keyCount++;
}// 插入关键字到 B 树
BTreeNode* insert(BTreeNode* root, int key) {if (root == NULL) {root = createNode(true);root->keys[0] = key;root->keyCount = 1;return root;}// 如果根节点已满if (root->keyCount == MAX_KEYS) {BTreeNode* newRoot = createNode(false);newRoot->children[0] = root;splitChild(newRoot, 0);int i = 0;if (newRoot->keys[0] < key) {i++;}insertNonFull(newRoot->children[i], key);return newRoot;}// 否则直接插入insertNonFull(root, key);return root;
}// 中序遍历
void inorderTraversal(BTreeNode* root) {if (root != NULL) {int i;for (i = 0; i < root->keyCount; i++) {inorderTraversal(root->children[i]);printf("%d ", root->keys[i]);}inorderTraversal(root->children[i]);}
}int main() {BTreeNode* root = NULL;// 插入关键字root = insert(root, 10);root = insert(root, 20);root = insert(root, 5);root = insert(root, 6);root = insert(root, 12);root = insert(root, 30);root = insert(root, 7);root = insert(root, 17);printf("Inorder traversal of B-Tree: ");inorderTraversal(root);printf("\n");// 查找关键字int key = 6;BTreeNode* result = search(root, key);if (result != NULL) {printf("Key %d found in the B-Tree.\n", key);} else {printf("Key %d not found in the B-Tree.\n", key);}return 0;
}
// 使用场景
//   B 树适用于动态插入、删除和查找操作。
//   B+ 树更适合范围查询和顺序访问。
//   B 树和 B+ 树查找时间复杂度均为 O(log n)，非常高效，广泛应用于数据库索引和文件系统中。
//   数据量极大，存储在磁盘或其他外部存储介质上。
//   数据库索引结构。

B+ 树是 B 树的改进版本，所有数据存储在叶子节点中，叶子节点通过链表相连，适合范围查询。由于实现较复杂，这里不加以演示。

散列表上的查找
1. 哈希查找（hash查找）

利用哈希函数将关键字直接映射到数组索引，查找时通过计算哈希值快速定位。

时间复杂度

  • 理想情况：O(1)。
  • 最坏情况（冲突严重）：O(n)。
#define SIZE 10int hash(int key) {return key % SIZE;  // 哈希函数
}void insert(int table[], int key) {int index = hash(key);while (table[index] != -1) {  // 线性探测解决冲突index = (index + 1) % SIZE;}table[index] = key;
}int search(int table[], int key) {int index = hash(key);while (table[index] != -1) {if (table[index] == key) return index;  // 找到目标值index = (index + 1) % SIZE;}return -1;  // 未找到
}
// 适用场景
//   高效查找需求，数据量大但内存充足。
//   实现字典、集合等数据结构。
图的查找
1. 广度优先搜索（BFS）
  • BFS 是一种逐层遍历图的算法：
    • 先访问起始节点。
    • 然后访问所有直接相邻的节点（第一层）。
    • 再访问上一层节点的下一层邻居，依此类推。
  • BFS 使用队列作为辅助数据结构，先进先出（FIFO）保证了按层访问节点。

代码描述：
给定一个无向图，求从起点节点 0 到目标节点 4 的最短路径。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAX 100// BFS 实现最短路径
void bfsShortestPath(int graph[MAX][MAX], int n, int start, int end) {int visited[MAX] = {0};  // 记录节点是否被访问int distance[MAX] = {0}; // 记录起点到每个节点的距离int previous[MAX];       // 记录路径for (int i = 0; i < n; i++) previous[i] = -1;int queue[MAX];int front = 0, rear = 0;// 起点入队queue[rear++] = start;visited[start] = 1;while (front < rear) {int current = queue[front++];// 遍历当前节点的邻居for (int i = 0; i < n; i++) {if (graph[current][i] == 1 && !visited[i]) {queue[rear++] = i; // 将邻居节点入队visited[i] = 1;    // 标记为已访问distance[i] = distance[current] + 1;previous[i] = current; // 记录路径// 如果找到目标节点，停止搜索if (i == end) {front = rear;break;}}}}// 输出路径和距离if (visited[end]) {printf("Shortest distance: %d\n", distance[end]);printf("Path: ");int path[MAX], pathLength = 0, node = end;while (node != -1) {path[pathLength++] = node;node = previous[node];}for (int i = pathLength - 1; i >= 0; i--) {printf("%d ", path[i]);}printf("\n");} else {printf("No path found from %d to %d\n", start, end);}
}int main() {// 定义无向图（邻接矩阵）int graph[MAX][MAX] = {{0, 1, 1, 0, 0},{1, 0, 1, 1, 0},{1, 1, 0, 0, 1},{0, 1, 0, 0, 1},{0, 0, 1, 1, 0}};int n = 5; // 节点数量int start = 0, end = 4;bfsShortestPath(graph, n, start, end);return 0;
}

输出：

Shortest distance: 2
Path: 0 2 4

BFS的应用

  1. 最短路径问题（无权图）：
    • BFS 能够找到从起始点到目标点的最短路径（路径长度以边的数量衡量）。
    • 应用场景：
      • 地图导航（如最短路径规划）。
      • 网络传输中的最短跳数计算。
  2. 连通性检查
    • 检查图中是否存在连接的路径，或统计连通分量的数量。
    • 应用场景：
      • 网络连通性分析。
      • 图的分区问题。
  3. 层次遍历
    • BFS 可以用于按层次访问节点。
    • 应用场景：
      • 社交网络中的层级推荐。
      • 树的层次遍历。
2. 深度优先搜索（DFS）
  • DFS 是一种尽可能沿着一条路径探索下去的图遍历算法：
    • 访问起始节点后，优先访问其第一个未访问的邻居。
    • 如果当前路径走到尽头，则回溯到上一个节点，继续探索其他未访问的邻居。
  • DFS 使用栈作为辅助数据结构，递归实现中使用函数调用栈。

代码描述：
给定一个有向图，找到从起点节点 0 到目标节点 4 的所有路径。

#include <stdio.h>
#include <stdlib.h>// 打印路径
void printPath(int path[], int pathLength) {for (int i = 0; i < pathLength; i++) {printf("%d ", path[i]);}printf("\n");
}// DFS 寻找所有路径
void dfsAllPaths(int graph[100][100], int n, int current, int end, int visited[], int path[], int pathLength) {visited[current] = 1;             // 标记当前节点为已访问path[pathLength++] = current;     // 添加当前节点到路径中if (current == end) {// 如果到达目标节点，输出路径printPath(path, pathLength);} else {// 遍历当前节点的邻居for (int i = 0; i < n; i++) {if (graph[current][i] == 1 && !visited[i]) {dfsAllPaths(graph, n, i, end, visited, path, pathLength);}}}visited[current] = 0;  // 回溯，标记当前节点为未访问
}int main() {// 定义有向图（邻接矩阵）int graph[100][100] = {{0, 1, 1, 0, 0},{0, 0, 1, 1, 0},{0, 0, 0, 0, 1},{0, 0, 0, 0, 1},{0, 0, 0, 0, 0}};int n = 5; // 节点数量int start = 0, end = 4;int visited[100] = {0};int path[100];int pathLength = 0;printf("All paths from %d to %d:\n", start, end);dfsAllPaths(graph, n, start, end, visited, path, pathLength);return 0;
}

输出：

All paths from 0 to 4:
0 1 3 4
0 1 2 4
0 2 4

DFS的应用

  1. 路径搜索问题
    • 找到从起点到目标点的所有路径。
    • 应用场景：
      • 迷宫求解。
      • 寻找所有可能的方案。
  2. 拓扑排序
    • 对有向无环图（DAG）进行排序，以确定任务的依赖顺序。
    • 应用场景：
      • 编译器中的任务调度。
      • 项目任务规划。
  3. 连通性检查
    • 统计图的连通分量，判断两个节点是否连通。
    • 应用场景：
      • 网络故障分析。
      • 图的分区问题。
  4. 图的循环检测
    • 检测图中是否存在环。
    • 应用场景：
      • 死锁检测。
      • 图依赖的验证。

BFS 与 DFS 的对比：

算法特点适用场景
广度优先搜索（BFS）逐层遍历，找到目标节点时路径一定是最短的（适用于无权图）。最短路径、层次遍历、连通性检查。
深度优先搜索（DFS）沿着路径搜索到底再回溯，适合搜寻所有路径或解决需要回溯的问题。所有路径、拓扑排序、循环检测。
选择使用 BFS 或 DFS：如果关心路径最短，使用 BFS。如果关心所有可能的路径或需要深入探索，使用 DFS。

选择合适的查找方法取决于数据的组织形式、应用场景和性能需求。例如，小规模无序数据：使用顺序查找更为简单易用；有序数据：使用二分查找快速高效；动态数据集合：使用二叉搜索树或平衡树；大规模数据：哈希查找或 B+ 树适合外部存储。

综上。希望该内容能对你有帮助。

以上。仅供学习与分享交流，请勿用于商业用途！转载需提前说明。

我是一个十分热爱技术的程序员，希望这篇文章能够对您有帮助，也希望认识更多热爱程序开发的小伙伴。
感谢！

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

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

相关文章

【C++】字符串与字符数|组操作详解：strcpy 和 strcat 的使用与解析

【C++】字符串与字符数|组操作详解：strcpy 和 strcat 的使用与解析

博客主页&#xff1a; [小ᶻ☡꙳ᵃⁱᵍᶜ꙳] 本文专栏: C 文章目录 &#x1f4af;前言&#x1f4af;一、字符串数组的基本操作&#x1f4af;二、strcpy 的用法详解1. strcpy 的功能与原型2. 使用示例与代码演示3. 注意事项4. 扩展&#xff1a;为什么不能直接用 &#xff1f…
阅读更多...
GWAS数据和软件下载

GWAS数据和软件下载

这部分主要是数据获取,以及软件配置方法。 一、配套数据和代码 数据和代码目前在不断的更新,最新的教程可以私信,我通过后手动发送最新版的pdf和数据代码。发送的压缩包,有电子版的pdf和数据下载链接,里面是最新的百度网盘的地址,下载到本地即可。然后根据pdf教程,结合配套的…
阅读更多...
Vue笔记-001-声明式渲染

Vue笔记-001-声明式渲染

https://cn.vuejs.org/tutorial/#step-2https://cn.vuejs.org/tutorial/#step-2 Vue 单文件组件 (Single-File Component&#xff0c;缩写为 SFC) 单文件组件是一种可复用的代码组织形式&#xff0c;它将从属于同一个组件的 HTML、CSS 和 JavaScript 封装在使用 .vue 后缀的文件…
阅读更多...
Scala_【5】函数式编程

Scala_【5】函数式编程

第五章 函数式编程函数和方法的区别函数声明函数参数可变参数参数默认值 函数至简原则匿名函数高阶函数函数作为值传递函数作为参数传递函数作为返回值 函数闭包&柯里化函数递归控制抽象惰性函数友情链接 函数式编程 面向对象编程 解决问题时&#xff0c;分解对象&#xff…
阅读更多...
（六）优化 ChatGPT 交互：任务式 Prompt 的力量

（六）优化 ChatGPT 交互：任务式 Prompt 的力量

&#x1f4e2;&#x1f4e2;&#x1f4e2; 大家好&#xff0c;我是云楼Yunlord&#xff0c;CSDN博客之星人工智能领域前三名&#xff0c;多年人工智能学习工作经验&#xff0c;一位兴趣稀奇古怪的【人工智能领域博主】&#xff01;&#xff01;&#xff01;&#x1f61c;&#…
阅读更多...
HarmonyOS-面试资料

HarmonyOS-面试资料

1. HarmonyOS-面试资料 1.1. HarmonyOS 优点、特点 1.1.1. 优点 &#xff08;1&#xff09;在国家方面&#xff0c;是国产的系统&#xff0c;受国家支持不会有限制的情况。   &#xff08;2&#xff09;设备互连18N(1:手机 8&#xff1a;平板、PC、vr设备、可穿戴设备、智慧…
阅读更多...
R语言基础| 中级绘图

R语言基础| 中级绘图

写在前面 前面第六章的图形主要是展示单分类变量或连续型变量的分布情况。本章主要研究二元变量或多元变量关系的可视化。更多教程可参考&#xff1a; R语言基础学习手册 图片集锦&#xff1a; 11.1 散点图 1&#xff09;添加最佳拟合曲线的散点图&#xff1a; 绘制汽车重…
阅读更多...
神经网络第一课

神经网络第一课

目录 背景知识生物神经元人工神经元模型神经网络训练神经网络结论背景知识 神经网络是一种人工智能模型，其主要受生物神经系统启发，重现了大脑中神经元之间相互连接的方式。 神经网络已在很多领域中取得显著成就，如图像识别、自然语言处理和语音识别等。 生物神经元 神经…
阅读更多...
Docker：安装 XXL-JOB 分布式调度任务的技术指南

Docker：安装 XXL-JOB 分布式调度任务的技术指南

1、简述 XXL-JOB 是一个分布式任务调度平台&#xff0c;提供简单易用的任务调度功能。它支持分布式调度、失败重试、任务监控和报警等功能。XXL-JOB 采用了服务端与执行器的架构&#xff0c;任务调度在服务端进行&#xff0c;而任务的实际执行则由各个执行器完成。 XXL-JOB 的…
阅读更多...
Git revert回滚

Git revert回滚

回退中间的某次提交&#xff08;此操作在预生产分支上比较常见&#xff09;&#xff0c;建议此方式使用命令进行操作&#xff08;做好注释&#xff0c;方便后续上线可以找到这个操作&#xff09; Git操作&#xff1a; 命令&#xff1a;revert -n 版本号 1&#xff1a;git re…
阅读更多...
新年到了！使用Python创建一个简易的接金元宝游戏

新年到了！使用Python创建一个简易的接金元宝游戏

引言 在本教程中&#xff0c;我们将一起学习如何使用Python编程语言和Pygame库来创建一个简单的休闲游戏——“接金元宝”。 准备工作 首先&#xff0c;确保你的计算机上已经安装了Python&#xff08;推荐3.6以上版本&#xff09;和Pygame库。如果还没有安装Pygame&#xff0…
阅读更多...
GoF23种设计模式 简介

GoF23种设计模式 简介

文章目录 面向对象(OO)设计原则&#xff08;7&#xff09;单一职责原则开闭原则里氏代换原则依赖倒转原则接口隔离原则合成复用原则迪米特法则 创建型模式 &#xff08;5&#xff09;工厂方法模式 &#xff08;类模式&#xff0c;其余都是对象模式&#xff09;抽象工厂模式建造…
阅读更多...
【数电尾灯设计】2022-8-16

【数电尾灯设计】2022-8-16

缘由数电尾灯设计问题&#xff0c;求解答--CSDN问答 从题目可以列出 000 100 010 111-----------4进制 000 100 010 110 001 101 011 111-----------8进制 由列出可知用16进制芯片的3个引脚可以获得8进制推导出4进制从而可用逻辑处理为4进制实现尾灯功能。之上第一步实现了尾灯…
阅读更多...
在线机考|2024华为实习秋招春招编程题（最新）——第3题_个性化歌单推荐系统_300分（十一）

在线机考|2024华为实习秋招春招编程题（最新）——第3题_个性化歌单推荐系统_300分（十一）

题目内容 假设你是音乐服务的开发者，为了提高用户体验需要解决推荐歌单的同质化问题，保证推荐给用户的所有歌单不包含相同歌曲的。给定一个包含N个歌单和M条歌单重复记录，每个歌单用一个从1到N的整数编号，歌单重复记录包含两个歌单的ID，表示两个歌单有相同的歌曲。 你的任…
阅读更多...
Ant Design Pro写项目的总结经验（react）

Ant Design Pro写项目的总结经验（react）

配置代理&#xff08;proxy&#xff09; 在config文件夹下面的config.ts里面配置修改 修改前&#xff1a;修改后&#xff1a; 修改账号框以及登录接口以及登录返回的code 由于它的账号框是username,但是我们接口请求要填写的是account&#xff0c;因此可以全局搜索进行替换…
阅读更多...
安卓14无法安装应用解决历程

安卓14无法安装应用解决历程

客户手机基本情况&#xff1a; 安卓14&#xff0c;对应的 targetSdkVersion 34 前天遇到了安卓14适配问题&#xff0c;客户发来的截图是这样的 描述&#xff1a;无法安装我们公司的B应用。 型号&#xff1a;三星google美版 解决步骤&#xff1a; 1、寻找其他安卓14手机测试…
阅读更多...
51单片机(二）中断系统与外部中断实验

51单片机(二）中断系统与外部中断实验

中断即单片机因为某些原因E暂定现在的工作P0&#xff0c;转去做其他的工作P1&#xff0c;完了之后继续之前的事P0&#xff0c;其他工作P1就是中断程序&#xff0c;原因E就是中断事件&#xff0c;原因由外部发生&#xff0c;程序不能预测到的是硬中断&#xff0c;可以由程度触发…
阅读更多...
66.基于SpringBoot + Vue实现的前后端分离-律师事务所案件管理系统（项目 + 论文）

66.基于SpringBoot + Vue实现的前后端分离-律师事务所案件管理系统（项目 + 论文）

项目介绍 传统办法管理信息首先需要花费的时间比较多&#xff0c;其次数据出错率比较高&#xff0c;而且对错误的数据进行更改也比较困难&#xff0c;最后&#xff0c;检索数据费事费力。因此&#xff0c;在计算机上安装律师事务所案件管理系统软件来发挥其高效地信息处理的作用…
阅读更多...
大数据组件(三)快速入门实时计算平台Dinky

大数据组件(三)快速入门实时计算平台Dinky

大数据组件(三)快速入门实时计算平台Dinky Dinky 是一个开箱即用的一站式实时计算平台&#xff08;同样&#xff0c;还有StreamPark&#xff09;&#xff0c;以 Apache Flink 为基础&#xff0c;连接数据湖仓等众多框架&#xff0c;致力于流批一体和湖仓一体的建设与实践。 Di…
阅读更多...
实际开发中,常见pdf|word|excel等文件的预览和下载

实际开发中,常见pdf|word|excel等文件的预览和下载

实际开发中,常见pdf|word|excel等文件的预览和下载 背景相关类型数据之间的转换1、File转Blob2、File转ArrayBuffer3、Blob转ArrayBuffer4、Blob转File5、ArrayBuffer转Blob6、ArrayBuffer转File 根据Blob/File类型生成可预览的Base64地址基于Blob类型的各种文件的下载各种类型…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023