实验 4：排序与查找

  • 东莞理工的学生可以借鉴，请勿抄袭

1.实验目的

通过实验达到：

  1. 理解典型排序的基本思想，掌握典型排序方法的思想和相应实现算法；

  2. 理解和掌握用二叉排序树(BST)实现动态查找的基本思想和相应的实现 算法。

  3. 理解和掌握哈希(HASH)存储结构的基本思想、哈希查找的思想、实现；

  4. 掌握典型查找、排序算法的算法分析。

2. 题目 1：排序

① 用 C 的 rand 函数随机生成若干个（例如 20-1000 个）在某个区间（例如 [0, 10000]）之间的整数保存数组中，以此数组元素作为关键字；

② 采用堆排序算法按非递增方式（从大到小）进行排序，给出操作的结果 及相应的操作次数（比较次数、移动次数）；

③ 采用快速排序算法按非递增方式（从大到小）进行排序，给出操作的结 果及相应的操作次数； ④ 采用归并排序算法按非递增方式（从大到小）进行排序，给出操作的结 果及相应的操作次数；

⑤ 主函数通过调用函数实现以上操作。

附加题：（每完成一个额外附加 5 分，上限 10 分）

① 10-27 设带头结点的单链表 L 中存放着要排序的 int 类型的若干个数据 元素，编写函数实现单链表存储结构的冒泡排序。

② 10-28 设带头结点的单链表 L 中存放着要排序的 int 类型的若干个数据 元素，编写函数实现单链表存储结构的直接选择排序。

③ 10-29 基数排序算法设计。

要求:

(1)设计基于顺序队列的基数排序函数。

(2)设计一个测试主函数，测试所设计的基于顺序队列的基数排序函数。

2.1. 数据结构设计

整形数组

2.2. 主要操作算法设计与分析

2.2.1. 获取随机数数组方法

int* createRandom()

返回类型：int*；

是否有参数：无

步骤：

  1. 通过srand和rand配合获取随机数（mod 10001）
  2. 用for循环获取N个

算法时间复杂度：

  • 时空复杂度为O(N);

2.2.2 打印数组函数

void display(int elem[])

返回类型：无；

是否有参数：无

步骤：

  1. 遍历数组打印每一个元素

算法时间复杂度：

  • 时间复杂度为O(N);

2.2.3. 堆排序函数

void heapSort(int elem[])

void createHeap(int elem[])

void shiftDown(int* elem, int root, int len)

返回类型：无返回值；

是否有参数：有，待排序数组

步骤：

  1. 调用createHeap对elem数组进行建堆操作
  2. 从(N - 2) / 2开始到0，对elem进行向下过滤的调整堆shiftDown操作
  3. 循环结束排序完成

算法时间复杂度：

  • 时间复杂度为O(Nlog2N);

2.2.4. 快速排序

void quickSort(int* arr)

void quick(int* arr, int left, int right)

int partition(int* arr, int left, int right)

int findMid(int* arr, int left, int right)

返回类型：无返回值；

是否有参数：有，待排序数组

步骤：

  1. 调用递归函数quick，传入left 0，right N-1
  2. 如果left大于等于right，直接返回
  3. 调用findMid找到数组的left到right这一部分数组中的中间值下标（三值取中），找到后这个下标与第一个元素进行交换
  4. 调用partition函数，进行快排划分，返回一个基准值pivot
  5. 调用quick，传入arr，左半部分
  6. 调用quick，传入arr，右半部分

算法时间复杂度：

  • 时间复杂度为O(Nlog2N);

2.2.5. 归并排序函数

void mergeSort(int* arr)

void mergeSorter(int* arr, int left, int right)

void merge(int* arr, int left, int right, int mid)

无返回值，有参数，待排序数组

步骤：

  1. 调用递归函数mergeSorter，传入arr，left，right
  2. 获得left和right中间值，mid
  3. 调用merge函数，传入arr，left，right，和mid
    • 合并有序顺序表操作
  4. 将左半部分和右半部分进行重复操作
  5. 最终排序完毕

复杂度分析：

时间复杂度：O(Nlog2N)

2.2.6. 主函数设计

int main() {
    int* arr = createRandom();
    heapSort(arr);
    printf("比较次数：%d, 交换次数：%d\n", compareCount, moveCount);
    display(arr);
    free(arr);
    arr = createRandom();
    quickSort(arr);
    printf("快排划分次数：%d\n", quickSortCount);
    display(arr);
    free(arr);
    arr = createRandom();
    mergeSort(arr);
    printf("归并次数：%d\n", mergeCount);
    display(arr);
    free(arr);
    return 0;
}

2.3. 程序运行过程及结果

在这里插入图片描述

3. 题目 2：二叉排序树(Binary Sort Tree, BST)的建立及动态查 找

生成若干个（比如 50 个）在某个区间（例如[-1000, 1000]）之间互不相同的 整数保存在数组 A 中，以此数组元素作为关键字，设计实现以下操作的程序：

① 建立对应的二叉排序树，按中序遍历算法输出所建立的 BST 树的结点；

② 对该二叉排序树，查找指定的关键字（输入要查找的整数），给出操作 的结论及相应的操作次数（比较次数）；

③ 对该二叉排序树，删除指定的关键字（输入要删除的整数），给出操作 的结论及相应的操作次数；

④ 按中序遍历算法输出二叉排序树的所有结点；

⑤ 主函数通过调用函数实现以上操作。

3.1. 数据结构设计

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

3.2. 主要操作算法设计与分析

3.2.1 创建以及中序遍历

  1. void freeTree(struct TreeNode* root)：

该函数用于释放二叉树的内存空间，它的具体步骤是：

  • 如果传入的 root 指针为空，则直接返回。
  • 否则，递归地释放其左子树的空间。
  • 接着，递归地释放其右子树的空间。
  • 最后，释放当前节点的空间。
  1. void inorderTraversal(struct TreeNode* root)：

该函数用于对二叉树进行中序遍历，并将节点的值依次输出到控制台中，具体步骤是：

  • 如果传入的 root 指针为空，则直接返回。
  • 否则，以递归的方式，先遍历左子树。
  • 然后输出当前节点的值。
  • 最后以递归的方式，遍历右子树。

算法时间复杂度：

  • 时空复杂度为O(N);

3.2.2 查找函数

该代码实现了在二叉搜索树中查找目标节点的功能，具体步骤如下：

  1. 如果传入的根节点指针 root 为空或者根节点的值就是目标值 target，那么增加一次比较次数 cmp 的计数器，并返回根节点指针 root。

  2. 如果目标值 target 小于根节点的值，那么增加两次比较次数 cmp 的计数器，然后递归地对根节点的左子树进行搜索。

  3. 否则，增加两次比较次数 cmp 的计数器，然后递归地对根节点的右子树进行搜索。

在这个过程中，计数器 cmp 用于记录比较目标值的次数，最终返回的是查找到的目标节点的指针，如果没有找到目标节点，返回空指针。

算法时间复杂度：

  • 时空复杂度为O(log2N);

3.2.3. 插入函数

struct TreeNode* insert(struct TreeNode* root, int val, int* cmp)

该代码实现了往二叉搜索树中插入一个节点的功能，具体说明如下：

传入参数：

  • root: 指向二叉搜索树根节点的指针。
  • val: 待插入的节点的值。
  • cmp: 指向用于记录比较次数的计数器的指针。

返回值：

  • 返回指向插入节点后的二叉搜索树根节点的指针。

具体步骤：

  1. 如果传入的根节点指针 root 为空，则增加一次比较次数 cmp 的计数器，并为新节点分配内存空间，然后创建该新节点，并将其左右指针都置为空，最后返回该新节点的指针。

  2. 如果目标值 val 小于根节点的值，则增加两次比较次数 cmp 的计数器，然后递归地将节点插入到根节点的左子树中，然后将该节点的左子节点指针指向递归返回的节点的指针。

  3. 否则，增加两次比较次数 cmp 的计数器，然后递归地将节点插入到根节点的右子树中，然后将该节点的右子节点指针指向递归返回的节点的指针。

算法时间复杂度：

  • 时空复杂度为O(log2N);

3.2.4 删除函数

struct TreeNode* delete(struct TreeNode* root, int target, int* cmp)

该代码实现了从二叉搜索树中删除一个节点的功能，具体说明如下：

传入参数：

  • root: 指向二叉搜索树根节点的指针。
  • target: 待删除节点的值。
  • cmp: 指向用于记录比较次数的计数器的指针。

返回值：

  • 返回指向删除节点后的二叉搜索树根节点的指针。

具体步骤：

  1. 如果传入的根节点指针 root 为空，则增加一次比较次数 cmp 的计数器，并返回空指针。

  2. 如果目标值 target 小于根节点的值，则增加两次比较次数 cmp 的计数器，然后递归地从根节点的左子树中删除目标节点，并将根节点的左子节点指针指向递归返回的节点的指针。

  3. 否则，如果目标值 target 大于根节点的值，则增加两次比较次数 cmp 的计数器，然后递归地从根节点的右子树中删除目标节点，并将根节点的右子节点指针指向递归返回的节点的指针。

  4. 如果目标值 target 等于根节点的值，则判断根节点是否存在左右子树：

  • 如果不存在左子树，则直接将根节点的右子树作为新的根节点，然后释放原根节点的内存空间。
  • 如果不存在右子树，则直接将根节点的左子树作为新的根节点，然后释放原根节点的内存空间。
  • 如果既有左子树又有右子树，则找到右子树中最小（或左子树中最大）的节点 cur，把其值赋给根节点，然后递归地从右子树中删除该最小节点的值，将根节点的右子节点指针指向递归返回的节点的指针。

算法时间复杂度：

  • 时间空间复杂度为O(log2N);（准确的来说是树的高度）

3.2.5. 主函数设计

int main() {
    int n = 50; // 数组元素个数
    int* arr = (int*)malloc(n * sizeof(int));
    srand(time(NULL));
    for (int i = 0; i < n; i++) {
        arr[i] = rand() % 2001 - 1000; // 随机生成-1000至1000之间的整数
        for (int j = 0; j < i; j++) { // 把相同的数过滤掉
            if (arr[i] == arr[j]) {
                i--;
                break;
            }
        }
    }

    struct TreeNode* root = NULL;
    int cmp = 0;

    for (int i = 0; i < n; i++) {
        root = insert(root, arr[i], &cmp);
    }
    printf("Inorder traversal of the BST:\n");
    inorderTraversal(root);
    printf("\n\n");

    int target;
    printf("请输入你想查找的节点： ");
    scanf("%d", &target);
    struct TreeNode* found = search(root, target, &cmp);
    if (found == NULL) {
        printf("找不到\n");
    }
    else {
        printf("Element %d 被找到了\n", found->val);
    }
    printf("比较操作次数：%d \n", cmp);

    int delete_val;
    printf("请输入你要删除的节点: ");
    scanf("%d", &delete_val);
    root = delete(root, delete_val, &cmp);
    if (root == NULL) {
        printf("树空了！");
    }
    else {
        printf(" %d 被删了，中序序列为:\n", delete_val);
        inorderTraversal(root);
    }
    printf("\n%d为比较次数.\n", cmp);

    printf("\n中序序列为:\n");
    inorderTraversal(root);
    printf("\n");

    freeTree(root);
    free(arr);

    return 0;
}

3.3. 程序运行过程及结果

在这里插入图片描述

4. 题目 3：哈希表(HASH)的建立及查找（选做题）

4.1. 数据结构设计

const int MAX_CAPACITY = 20; // 哈希表大小
const int PRIME_NUM = 17; // 哈希函数的p值

// 哈希表节点
struct Node {
    int val;
    struct Node* next;
};

4.2. 主要操作算法设计与分析

4.2.1 创建函数

hashFunc 函数：

传入参数：

  • key: 待哈希的关键字。

返回值：

  • 哈希函数计算出的哈希值。

步骤：

  • 对传入的关键字 key 取模 PRIME_NUM，然后再加上 PRIME_NUM，最后再对 PRIME_NUM 取模，得到哈希函数的计算结果。

createNode函数：

传入参数：

  • val: 新节点的值。

返回值：

  • 指向新节点的指针。

步骤：

  • 分配一个大小为 struct Node 的内存空间 node。
  • 将节点的 val 值设为传入的值 val。
  • 将节点的 next 指针设为空指针。
  • 返回指向新节点的指针。

这两个函数的时间复杂度和空间复杂度都比较低，hashFunc 函数的时间复杂度为 O(1)，createNode 函数的时间复杂度也为 O(1)，它们的空间复杂度也都为 O(1)。

4.2.2 查找函数

// 查找哈希表中值为target的节点，返回该节点所在的哈希表位置（下标） int search(struct Node** hashTable, int target, int* cmp)

传入参数：

  • hashTable: 指向哈希表首地址的指针。
  • target: 待查找的值。
  • cmp: 指向用于记录比较次数的计数器的指针。

返回值：

  • 如果在哈希表中找到了值为 target 的节点，则返回该节点所在的哈希表位置（下标）。
  • 如果在哈希表中没有找到值为 target 的节点，则返回 -1。

步骤：

  • 首先根据哈希函数计算出待查找值 target 的哈希表位置 index。
  • 然后在哈希表的 index 位置处查找与 target 相等的节点。
  • 如果找到了与 target 相等的节点，则直接返回该节点所在的哈希表位置 index。
  • 如果没找到与 target 相等的节点，则将指针 cur 指向哈希表中下一个节点，继续比较，直到遍历完所有的节点。
  • 如果最终仍未找到与 target 相等的节点，则返回 -1。

算法复杂度分析：

该函数的时间复杂度与平均每个位置的链表长度有关，为 O(1+K)，其中 K 表示平均每个位置的链表长度。该函数的空间复杂度为 O(n)，其中 n 表示哈希表中节点的数量。

4.2.3. 插入函数

void insert(struct Node** hashTable, int val, int* cmp)

该代码实现了往哈希表中插入一个新节点的功能，具体说明如下：

传入参数：

  • hashTable: 指向哈希表首地址的指针。
  • val: 待插入节点的值。
  • cmp: 指向用于记录比较次数的计数器的指针。

返回值：

  • 无返回值。

具体步骤：

  • 首先根据哈希函数计算出待插入节点的哈希表位置 index。
  • 如果该位置下的链表为空，则直接在该位置处创建一个新节点，并将该节点插入到链表的首位。
  • 如果该位置下的链表不为空，则需要查找链表的末尾，然后在末尾处创建一个新节点，并将其插入到链表的末尾。

算法时间复杂度：

该函数的时间复杂度取决于链表长度，并且最坏情况的时间复杂度为 O(n)，其中 n 表示链表的长度。该函数的空间复杂度取决于哈希表的大小和节点个数，因为哈希表中的每个位置都可能含有多个节点，所以空间复杂度最坏情况下为 O(n)，其中 n 表示节点的数量。

4.2.4 删除函数

void delete(struct Node** hashTable, int target, int* cmp)

传入参数：

  • hashTable: 指向哈希表首地址的指针。
  • target: 待删除节点的值。
  • cmp: 指向用于记录比较次数的计数器的指针。

返回值：

  • 无返回值。

步骤：

  • 首先根据哈希函数计算出值为 target 的节点所在的哈希表位置 index。
  • 然后在哈希表的 index 位置处查找与 target 相等的节点 cur，如果 cur 节点不存在（即该位置下的链表为空），则直接返回。
  • 如果 cur 节点恰好就是哈希表里的第一个节点，则将哈希表的 index 位置指向 cur 的下一个节点，然后释放 cur 指向节点的内存空间。
  • 如果 cur 节点不是哈希表的第一个节点，则需要沿着链表继续查找，直到找到与 target 相等的节点 temp。
  • 当找到与 target 相等的节点 temp 时，先将该节点的前一个节点 cur 的 next 指针指向 temp 节点的下一个节点，然后释放 temp 指向节点的内存空间即可。

算法时间复杂度：

  • 该函数的时间复杂度取决于链表长度，并且最坏情况的时间复杂度为 O(n)，其中 n 表示链表的长度。该函数的空间复杂度为 O(1)。

4.2.5. 输出哈希表

void printHashTable(struct Node** hashTable)

传入参数：

  • hashTable: 指向哈希表首地址的指针。

返回值：

  • 无返回值。

具体步骤：

  • 遍历整个哈希表，对于每个位置 i，输出该位置对应的链表中所有节点的值。

注意：需要在每个节点的值之间输出空格，最后需要在每行输出结束后换行。

算法复杂度分析：

  • 该函数的时间复杂度为 O(n)，其中 n 表示哈希表中节点的数量。该函数的空间复杂度为 O(1)。

4.2.6. 主函数设计

int main() {
        int n = 50; // 数组元素个数
    int* arr = (int*)malloc(sizeof(int) * n);
    srand(0);
    for (int i = 0; i < n; i++) {
        arr[i] = rand() % 901 + 100; // 随机生成100至1000之间的整数
        for (int j = 0; j < i; j++) { // 把相同的数过滤掉
            if (arr[i] == arr[j]) {
                i--;
                break;
            }
        }
    }

    struct Node* hashTable = (struct Node*)calloc(MAX_CAPACITY, sizeof(struct Node));
    int cmp = 0;

    // 建立哈希表
    for (int i = 0; i < n; i++) {
        insert(hashTable, arr[i], &cmp);
    }
    printf("哈希表已建立：\n");
    printHashTable(hashTable); // 输出哈希表
    printf("\n");

    // 查找
    int target;
    printf("请输入要查找的元素：");
    scanf("%d", &target);
    int index = search(hashTable, target, &cmp);
    if (index < 0) {
        printf("没有找到该元素。\n");
    }
    else {
        printf("找到了元素 %d，它在哈希表的位置是 %d。\n", target, index);
    }
    printf("总共进行了 %d 次比较。\n", cmp);
    printf("\n");

    // 删除
    int delete_val;
    printf("请输入要删除的元素：");
    scanf("%d", &delete_val);
    delete(hashTable, delete_val, &cmp);
    printf("元素 %d 已删除。\n", delete_val);
    printf("删除后的哈希表：\n");
    printHashTable(hashTable); // 输出哈希表
    printf("总共进行了 %d 次比较。\n", cmp);

    free(arr);
    free(hashTable);

    return 0;
}

4.3. 程序运行过程及结果

在这里插入图片描述
在这里插入图片描述

5. 总结

  1. 快速排序使用分治策略实现，时间复杂度平均为 O(nlogn)，但最坏情况下会退化为 O(n^2)。
  2. 归并排序同样也使用分治策略实现，时间复杂度稳定为 O(nlogn)，但需要使用额外的空间存储中间结果。
  3. 堆排序的时间复杂度也为 O(nlogn)，且不需要使用额外空间，但排序结果不稳定。
  4. 哈希表通过哈希函数将数据映射为连续空间上的一个位置，能够实现常数时间内的查找操作，但哈希函数的选择与负载因子会影响哈希表的性能。
  5. 搜索树通过以节点间的关系来描述数据之间的有序关系（如二叉搜索树），能够实现 O(logn) 的时间复杂度，但最坏情况下也可能变为 O(n)。不同的算法适用于不同的场景，需要根据具体应用场景结合时间和空间复杂度进行合理选择。

6. 附录：源代码

我已上传附件：“实验排序.zip”

码云链接：排序与查找

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Django】图形验证码显示及验证

【Django】图形验证码显示及验证

图形验证码显示及验证 开发项目时&#xff0c;在登陆或者注册功能中为防止脚本恶意破坏系统&#xff0c;故而添加图形验证码。 文章目录 图形验证码显示及验证1 安装配置2 验证码显示及正确性验证3 效果显示 1 安装配置 安装第三方库 pip install django-simple-captcha配置s…
阅读更多...
《计算机系统与网络安全》 第六章 密钥管理

《计算机系统与网络安全》 第六章 密钥管理

&#x1f337;&#x1f341; 博主 libin9iOak带您 Go to New World.✨&#x1f341; &#x1f984; 个人主页——libin9iOak的博客&#x1f390; &#x1f433; 《面试题大全》 文章图文并茂&#x1f995;生动形象&#x1f996;简单易学&#xff01;欢迎大家来踩踩~&#x1f33…
阅读更多...
mysql8.0新特性详解

mysql8.0新特性详解

一、my.ini或my.cnf的全局参数 一个连接最少占用内存是256K&#xff0c;最大是64M&#xff0c;如果一个连接的请求数据超过64MB&#xff08;比如排序&#xff09;&#xff0c;就会申请临时空间&#xff0c;放到硬盘上。 #最大连接数 max_connections3000 #最大用户连接数 max_…
阅读更多...
RS485转Profinet通讯

RS485转Profinet通讯

RS485转Profinet通讯 概述系统组成流量积算仪网关 软件总结 概述 一个支持RS485的流量积算仪的数据要被Profinet的PLC读取。制作一个网关&#xff0c;实现RS485到Profinet的转换。 系统组成 流量积算仪 支持RS485通讯&#xff0c;通讯协议是modbus RTU。采用功能码3可以读取…
阅读更多...
ChatGPT从入门到精通，深入认识Prompt

ChatGPT从入门到精通，深入认识Prompt

ChatGPT从入门到精通&#xff0c;一站式掌握办公自动化/爬虫/数据分析和可视化图表制作 全面AI时代就在转角 道路已经铺好了 “局外人”or“先行者” 就在此刻 等你决定 让ChatGPT帮你高效实现职场办公&#xff01;行动起来吧。欢迎关注专栏 1、ChatGPT从入门到精通&#xff0…
阅读更多...
【SQL Server】数据库开发指南（八）高级数据处理技术 MS-SQL 事务、异常和游标的深入研究

【SQL Server】数据库开发指南（八）高级数据处理技术 MS-SQL 事务、异常和游标的深入研究

本系列博文还在更新中&#xff0c;收录在专栏&#xff1a;#MS-SQL Server 专栏中。 本系列文章列表如下&#xff1a; 【SQL Server】 Linux 运维下对 SQL Server 进行安装、升级、回滚、卸载操作 【SQL Server】数据库开发指南&#xff08;一&#xff09;数据库设计的核心概念…
阅读更多...
【Unity 实用插件篇】 | UI适配神器 Device Simulator 移动设备模拟器 的详细使用方法

【Unity 实用插件篇】 | UI适配神器 Device Simulator 移动设备模拟器 的详细使用方法

前言 【Unity 实用插件篇】 UI适配神器 Device Simulator 移动设备模拟器 的详细使用方法一、安装Device Simulator包二、使用Device Simulator模拟各种设备三、自定义设备类型信息 总结 &#x1f3ac; 博客主页&#xff1a;https://xiaoy.blog.csdn.net &#x1f3a5; 本文由…
阅读更多...
错误C2039:‘退出‘:不是‘`全局名称空间‘的成员

错误C2039:‘退出‘:不是‘`全局名称空间‘的成员

问题 VC\Tools\MSVC\14.27.29110\include 目录里的cstdint文件的内容 原因 一种典型的Microsoft产品错误. 解决 运行 点击修复
阅读更多...
Windows 驱动开发环境搭建

Windows 驱动开发环境搭建

Windows 驱动开发环境搭建及 windbg 调试工具安装使用 引言了解 Windows 驱动开发环境下载 Windows 驱动开发环境根据需要下载安装对应版本的 Visual Studio下载安装对应的 WDK 工具包 编写第一个驱动代码总结参考资料 引言 对于 Windows 驱动开发&#xff0c;在微软官方的文档…
阅读更多...
windows 下安装 mysql-8.0.25 解压版

windows 下安装 mysql-8.0.25 解压版

介绍 此文介绍 mysql-8.0.25-winx64 的 zip 解压版&#xff0c;在 windows 下的安装与配置过程。 官方下载 官网下载页&#xff1a; https://downloads.mysql.com/archives/community/ 进入官网&#xff0c;选择默认版本就行&#xff0c;不需要包含测试工具套件的版本 本地解…
阅读更多...
【spring源码系列-03】xml配置文件启动spring时refresh的前置工作

【spring源码系列-03】xml配置文件启动spring时refresh的前置工作

Spring源码系列整体栏目 内容链接地址【一】spring源码整体概述https://blog.csdn.net/zhenghuishengq/article/details/130940885【二】通过refresh方法剖析IOC的整体流程https://blog.csdn.net/zhenghuishengq/article/details/131003428【三】xml配置文件启动spring时refres…
阅读更多...
[RocketMQ] Consumer消费者启动主要流程源码 (六)

[RocketMQ] Consumer消费者启动主要流程源码 (六)

客户端常用的消费者类是DefaultMQPushConsumer, DefaultMQPushConsumer的构造器以及start方法的源码。 1.创建DefaultMQPushConsumer实例 最终都是调用下面四个参数的构造函数: /*** 创建DefaultMQPushConsumer实例** param namespace namespace地址* par…
阅读更多...
两两交换链表中的节点（LeetCode 24）

两两交换链表中的节点（LeetCode 24）

题目 24. 两两交换链表中的节点 思路 最开始自己画&#xff0c;越画越复杂比较复杂&#xff0c;写不出来&#xff01;&#xff08;呜呜&#xff09;去看了解题思路&#xff0c;发现只需要三步。&#xff0c;按以下思路写了代码&#xff0c;循环停止那里的条件我还以有更好的写…
阅读更多...
【Docker】Docker Desktop更换非C盘符(减轻占用率)

【Docker】Docker Desktop更换非C盘符(减轻占用率)

Win10中的Docker Desktop调整到其他盘符&#xff0c;由于新版本已经不让修改软连接了&#xff0c;只好另谋策略&#xff0c;最终还是改成功了。 出现问题 使用软连接修改 上面代码我们可以科幻的理解一下 幻想破灭 //TODO 用户点击执行安装 if(检查文件夹是否软连接){有则&a…
阅读更多...
虚拟机中Ubuntu 22上传框被黑框包裹的解决方法

虚拟机中Ubuntu 22上传框被黑框包裹的解决方法

虚拟机中Ubuntu 22上传框被黑框包裹的解决方法 现象解决方法 现象 在vm17下的ubuntu22使用上传表单时出现了这种不和谐的现象&#xff0c;被领导批评一通。最后费劲心思&#xff0c;找到了这个问题的解决方法。 解决方法 解决方法特别容易&#xff0c;在虚拟机的设置中&…
阅读更多...
模型实战（13）之YOLOv8实现手语字母检测与识别+权重分享

模型实战（13）之YOLOv8实现手语字母检测与识别+权重分享

YOLOv8实现手语字母检测与识别+权重分享 本文借助yolov8 实现手语字母的检测与识别：先检测手的ROI，进而对手语表达的字母含义进行识别全文将从环境搭建、模型训练及预测来展开对整个算法流程进行讲解文中给出了开源数据集链接及从 Roboflow 上的下载教程实现效果如下： 1. 环…
阅读更多...
信驰达推出基于CC2340的BLE PEPS解决方案

信驰达推出基于CC2340的BLE PEPS解决方案

近日&#xff0c;TI发布了第四代低功耗蓝牙SoC-CC2340&#xff0c;该产品凝聚了TI 公司20多年的射频经验&#xff0c;在成本、尺寸和性能上做了优化设计&#xff0c;是目前市场上最有价值的低功耗蓝牙SoC之一。 TI CC2340 SoC采用48 MHz ARM Cortex-M0 MCU&#xff0c;高达512…
阅读更多...
LLM 应用参考架构：ArchGuard Co-mate 实践示例

LLM 应用参考架构：ArchGuard Co-mate 实践示例

随着&#xff0c;对于 LLM 应用于架构领域探索的进一步深入&#xff0c;以及 ArchGuard Co-mate 开发进入深入区&#xff0c;我们发现越来越多的通用模式。 在先前的文章里&#xff0c;我们总结了一系列的设计原则&#xff0c;在这篇文章里&#xff0c;我们将介绍 ArchGuard Co…
阅读更多...
MATLAB 之 数值积分和离散傅里叶变换

MATLAB 之 数值积分和离散傅里叶变换

这里写目录标题 一、数值积分1. 数值积分基本原理2. 数值积分的实现2.1 变步长辛普森法2.2 自适应积分法2.3 高斯——克朗罗德法2.4 梯形积分法2.5 累计梯形积分 3. 多重定积分的数值求解 二、离散傅里叶变换1. 离散傅里叶变换算法简介2. 离散傅里叶变换的实现 一、数值积分 数…
阅读更多...
死信是什么，如何运用RabbitMQ的死信机制？

死信是什么，如何运用RabbitMQ的死信机制？

系列文章目录 手把手教你&#xff0c;本地RabbitMQ服务搭建&#xff08;windows&#xff09; 消息队列选型——为什么选择RabbitMQ RabbitMQ 五种消息模型 RabbitMQ 能保证消息可靠性吗 推或拉&#xff1f; RabbitMQ 消费模式该如何选择 死信是什么&#xff0c;如何运用Rabbit…
阅读更多...
最新文章

Copyright @ 2022~2023

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