算法篇_C语言实现霍夫曼编码算法

news2024/9/20 8:54:54

一、前言

霍夫曼编码（Huffman Coding）是一种广泛使用的数据压缩算法，特别适用于无损数据压缩。它是由David A. Huffman在1952年提出的，并且通常用于文件压缩和传输中减少数据量。霍夫曼编码的核心思想是使用变长编码表对源数据进行编码，其中较频繁出现的数据项会被赋予较短的编码，而较少出现的数据项则会被赋予较长的编码。

该编码方法通过构建一种特殊的二叉树——霍夫曼树，为数据中的各个符号分配长度可变的前缀码，使得高频出现的符号具有较短的编码，而低频出现的符号则具有较长的编码。这种特性使得霍夫曼编码非常适合于压缩具有不均匀符号频率分布的数据集，能够有效地减小数据的存储空间或传输所需的带宽。

霍夫曼编码的工作原理如下：首先统计输入数据中每个符号出现的频率；然后基于这些频率值构造一个最小堆，其中堆中的每个元素都是一个只包含一个符号及其频率的树节点；接着反复从堆中取出频率最小的两个节点，合并成一个新的内部节点，该节点的频率为两个子节点频率之和，并将这个新节点放回堆中；重复这一过程直到堆中只剩下一个节点，这个节点即为霍夫曼树的根节点；最后，从根节点出发遍历整棵树，定义从根到任一叶节点的路径上，向左走标记为0，向右走标记为1，这样每个叶节点就对应了一个唯一的二进制编码，这就是霍夫曼编码。

霍夫曼编码的一个关键特征是其编码具有前缀性质，即没有任何一个符号的编码是另一个符号编码的前缀，这保证了在解码过程中可以唯一确定每一个编码所代表的符号，从而确保了压缩和解压过程的一致性。此外，霍夫曼编码是熵编码的一种形式，它利用了数据的统计特性来进行压缩，理论上可以达到接近于信息熵的压缩效率，即在理想情况下，压缩后的数据量等于数据的信息熵。

霍夫曼编码在文件压缩软件中，如WinZip、7-Zip，使用霍夫曼编码来压缩文件；在网络通信中，为了提高传输效率，会采用霍夫曼编码来压缩数据流；在图像处理和视频编码中，霍夫曼编码经常与其他编码技术结合使用，比如JPEG图像压缩标准就使用了霍夫曼编码来进一步压缩量化后的离散余弦变换系数。

在这里插入图片描述

下面是霍夫曼编码的基本步骤：

  1. 统计字符频率：

    • 首先需要统计输入数据中每个字符出现的次数。

  2. 创建霍夫曼树（也称为最优二叉树）：

    • 创建一个叶子节点集合，每个叶子节点包含一个字符和它的频率。
    • 反复执行以下操作，直到所有节点合并成一棵树：
      • 从集合中选出两个频率最低的节点作为新节点的左右子节点。
      • 新节点的频率是其两个子节点频率之和。
      • 将这个新节点加入集合中。
    • 最终剩下的那棵树就是霍夫曼树。

  3. 生成编码规则：

    • 从霍夫曼树的根节点出发，向左走标记为0，向右走标记为1。
    • 每个叶子节点对应的路径上的数字序列即为其霍夫曼编码。

  4. 编码数据：

    • 使用生成的霍夫曼编码表对原始数据进行编码。

  5. 解码数据：

    • 解码时只需按照霍夫曼树从根节点开始，根据0或1沿着树向下移动即可还原出原始数据。

霍夫曼编码的一个重要特点是它是前缀编码，这意味着没有一个编码是另一个编码的前缀。这样可以确保编码后的数据可以唯一地解码回原始数据。

举个简单的例子来说明霍夫曼编码的过程：

假设我们有这样一个字符串：“ABACDAACAC”，其中字符A出现了5次，B出现了1次，C出现了4次，D出现了1次。

  1. 统计字符频率：

    • A: 5
    • B: 1
    • C: 4
    • D: 1

  2. 创建霍夫曼树：

    • 构建初始节点集合：{A(5), B(1), C(4), D(1)}
    • 合并B(1)和D(1)，得到一个新节点BD(2)
    • 合并C(4)和BD(2)，得到一个新节点CBDB(6)
    • 最后合并A(5)和CBDB(6)，得到霍夫曼树的根节点。

  3. 生成编码规则：

    • A: 0
    • B: 110
    • C: 10
    • D: 111

  4. 编码数据：

    • “ABACDAACAC”编码后变为：“0110100011101000100”

二、算法设计（C语言）

2.1 霍夫曼编码算法实现

下面代码里实现了创建霍夫曼树、生成霍夫曼编码、对输入文本进行编码和解码的功能。编译运行这段代码可以得到每个字符的霍夫曼编码。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_TREE_HT 100

// 霍夫曼树节点
struct MinHeapNode {
    char data;
    unsigned freq;
    struct MinHeapNode* left, * right;
};

// 最小堆
struct MinHeap {
    unsigned size;
    unsigned capacity;
    struct MinHeapNode** array;
};

// 创建新节点
struct MinHeapNode* newNode(char data, unsigned freq) {
    struct MinHeapNode* temp = (struct MinHeapNode*)malloc(sizeof(struct MinHeapNode));
    temp->left = temp->right = NULL;
    temp->data = data;
    temp->freq = freq;
    return temp;
}

// 创建最小堆
struct MinHeap* createMinHeap(unsigned capacity) {
    struct MinHeap* minHeap = (struct MinHeap*)malloc(sizeof(struct MinHeap));
    minHeap->size = 0;
    minHeap->capacity = capacity;
    minHeap->array = (struct MinHeapNode**)malloc(minHeap->capacity * sizeof(struct MinHeapNode*));
    return minHeap;
}

// 交换两个最小堆节点
void swapMinHeapNode(struct MinHeapNode** a, struct MinHeapNode** b) {
    struct MinHeapNode* t = *a;
    *a = *b;
    *b = t;
}

// 堆化
void minHeapify(struct MinHeap* minHeap, int idx) {
    int smallest = idx;
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;

    if (left < minHeap->size && minHeap->array[left]->freq < minHeap->array[smallest]->freq)
        smallest = left;

    if (right < minHeap->size && minHeap->array[right]->freq < minHeap->array[smallest]->freq)
        smallest = right;

    if (smallest != idx) {
        swapMinHeapNode(&minHeap->array[smallest], &minHeap->array[idx]);
        minHeapify(minHeap, smallest);
    }
}

// 检查大小是否为1
int isSizeOne(struct MinHeap* minHeap) {
    return (minHeap->size == 1);
}

// 提取最小值节点
struct MinHeapNode* extractMin(struct MinHeap* minHeap) {
    struct MinHeapNode* temp = minHeap->array[0];
    minHeap->array[0] = minHeap->array[minHeap->size - 1];
    --minHeap->size;
    minHeapify(minHeap, 0);
    return temp;
}

// 插入最小堆
void insertMinHeap(struct MinHeap* minHeap, struct MinHeapNode* minHeapNode) {
    ++minHeap->size;
    int i = minHeap->size - 1;

    while (i && minHeapNode->freq < minHeap->array[(i - 1) / 2]->freq) {
        minHeap->array[i] = minHeap->array[(i - 1) / 2];
        i = (i - 1) / 2;
    }
    minHeap->array[i] = minHeapNode;
}

// 构建最小堆
void buildMinHeap(struct MinHeap* minHeap) {
    int n = minHeap->size - 1;
    int i;

    for (i = (n - 1) / 2; i >= 0; --i)
        minHeapify(minHeap, i);
}

// 检查是否是叶子节点
int isLeaf(struct MinHeapNode* root) {
    return !(root->left) && !(root->right);
}

// 创建和构建最小堆
struct MinHeap* createAndBuildMinHeap(char data[], int freq[], int size) {
    struct MinHeap* minHeap = createMinHeap(size);

    for (int i = 0; i < size; ++i)
        minHeap->array[i] = newNode(data[i], freq[i]);

    minHeap->size = size;
    buildMinHeap(minHeap);
    return minHeap;
}

// 构建霍夫曼树
struct MinHeapNode* buildHuffmanTree(char data[], int freq[], int size) {
    struct MinHeapNode* left, * right, * top;
    struct MinHeap* minHeap = createAndBuildMinHeap(data, freq, size);

    while (!isSizeOne(minHeap)) {
        left = extractMin(minHeap);
        right = extractMin(minHeap);

        top = newNode('$', left->freq + right->freq);
        top->left = left;
        top->right = right;

        insertMinHeap(minHeap, top);
    }
    return extractMin(minHeap);
}

// 打印编码
void printCodes(struct MinHeapNode* root, int arr[], int top) {
    if (root->left) {
        arr[top] = 0;
        printCodes(root->left, arr, top + 1);
    }

    if (root->right) {
        arr[top] = 1;
        printCodes(root->right, arr, top + 1);
    }

    if (isLeaf(root)) {
        printf("%c: ", root->data);
        for (int i = 0; i < top; ++i)
            printf("%d", arr[i]);
        printf("\n");
    }
}

// 霍夫曼编码主函数
void HuffmanCodes(char data[], int freq[], int size) {
    struct MinHeapNode* root = buildHuffmanTree(data, freq, size);
    int arr[MAX_TREE_HT], top = 0;
    printCodes(root, arr, top);
}

// 主函数
int main() {
    char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
    int freq[] = { 5, 9, 12, 13, 16, 45 };
    int size = sizeof(arr) / sizeof(arr[0]);

    HuffmanCodes(arr, freq, size);

    return 0;
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2.2 数据的编码与还原

以下是使用霍夫曼编码算法对一段数据进行压缩和还原。代码包括生成霍夫曼树、生成编码表、对数据进行压缩和还原的功能。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_TREE_HT 100
#define MAX_CHAR 256

// 霍夫曼树节点
struct MinHeapNode {
    unsigned char data;
    unsigned freq;
    struct MinHeapNode* left, * right;
};

// 最小堆
struct MinHeap {
    unsigned size;
    unsigned capacity;
    struct MinHeapNode** array;
};

// 创建新节点
struct MinHeapNode* newNode(unsigned char data, unsigned freq) {
    struct MinHeapNode* temp = (struct MinHeapNode*)malloc(sizeof(struct MinHeapNode));
    temp->left = temp->right = NULL;
    temp->data = data;
    temp->freq = freq;
    return temp;
}

// 创建最小堆
struct MinHeap* createMinHeap(unsigned capacity) {
    struct MinHeap* minHeap = (struct MinHeap*)malloc(sizeof(struct MinHeap));
    minHeap->size = 0;
    minHeap->capacity = capacity;
    minHeap->array = (struct MinHeapNode**)malloc(minHeap->capacity * sizeof(struct MinHeapNode*));
    return minHeap;
}

// 交换两个最小堆节点
void swapMinHeapNode(struct MinHeapNode** a, struct MinHeapNode** b) {
    struct MinHeapNode* t = *a;
    *a = *b;
    *b = t;
}

// 堆化
void minHeapify(struct MinHeap* minHeap, int idx) {
    int smallest = idx;
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;

    if (left < minHeap->size && minHeap->array[left]->freq < minHeap->array[smallest]->freq)
        smallest = left;

    if (right < minHeap->size && minHeap->array[right]->freq < minHeap->array[smallest]->freq)
        smallest = right;

    if (smallest != idx) {
        swapMinHeapNode(&minHeap->array[smallest], &minHeap->array[idx]);
        minHeapify(minHeap, smallest);
    }
}

// 检查大小是否为1
int isSizeOne(struct MinHeap* minHeap) {
    return (minHeap->size == 1);
}

// 提取最小值节点
struct MinHeapNode* extractMin(struct MinHeap* minHeap) {
    struct MinHeapNode* temp = minHeap->array[0];
    minHeap->array[0] = minHeap->array[minHeap->size - 1];
    --minHeap->size;
    minHeapify(minHeap, 0);
    return temp;
}

// 插入最小堆
void insertMinHeap(struct MinHeap* minHeap, struct MinHeapNode* minHeapNode) {
    ++minHeap->size;
    int i = minHeap->size - 1;

    while (i && minHeapNode->freq < minHeap->array[(i - 1) / 2]->freq) {
        minHeap->array[i] = minHeap->array[(i - 1) / 2];
        i = (i - 1) / 2;
    }
    minHeap->array[i] = minHeapNode;
}

// 构建最小堆
void buildMinHeap(struct MinHeap* minHeap) {
    int n = minHeap->size - 1;
    int i;

    for (i = (n - 1) / 2; i >= 0; --i)
        minHeapify(minHeap, i);
}

// 检查是否是叶子节点
int isLeaf(struct MinHeapNode* root) {
    return !(root->left) && !(root->right);
}

// 创建和构建最小堆
struct MinHeap* createAndBuildMinHeap(unsigned char data[], int freq[], int size) {
    struct MinHeap* minHeap = createMinHeap(size);

    for (int i = 0; i < size; ++i)
        minHeap->array[i] = newNode(data[i], freq[i]);

    minHeap->size = size;
    buildMinHeap(minHeap);
    return minHeap;
}

// 构建霍夫曼树
struct MinHeapNode* buildHuffmanTree(unsigned char data[], int freq[], int size) {
    struct MinHeapNode* left, * right, * top;
    struct MinHeap* minHeap = createAndBuildMinHeap(data, freq, size);

    while (!isSizeOne(minHeap)) {
        left = extractMin(minHeap);
        right = extractMin(minHeap);

        top = newNode('$', left->freq + right->freq);
        top->left = left;
        top->right = right;

        insertMinHeap(minHeap, top);
    }
    return extractMin(minHeap);
}

// 生成编码表
void generateCodes(struct MinHeapNode* root, int arr[], int top, char* codes[]) {
    if (root->left) {
        arr[top] = 0;
        generateCodes(root->left, arr, top + 1, codes);
    }

    if (root->right) {
        arr[top] = 1;
        generateCodes(root->right, arr, top + 1, codes);
    }

    if (isLeaf(root)) {
        codes[root->data] = (char*)malloc(top + 1);
        for (int i = 0; i < top; ++i) {
            codes[root->data][i] = arr[i] + '0';
        }
        codes[root->data][top] = '\0';
    }
}

// 压缩数据
void compressData(const char* data, char* codes[], char* compressed) {
    while (*data) {
        strcat(compressed, codes[(unsigned char)*data]);
        data++;
    }
}

// 解码霍夫曼树
void decodeHuffmanTree(struct MinHeapNode* root, char* encoded, char* decoded) {
    struct MinHeapNode* current = root;
    while (*encoded) {
        if (*encoded == '0') {
            current = current->left;
        }
        else {
            current = current->right;
        }

        if (isLeaf(current)) {
            *decoded++ = current->data;
            current = root;
        }
        encoded++;
    }
    *decoded = '\0';
}

// 打印编码表
void printCodes(char* codes[]) {
    for (int i = 0; i < MAX_CHAR; i++) {
        if (codes[i]) {
            printf("%c: %s\n", i, codes[i]);
        }
    }
}

// 主函数
int main() {
    const char* data = "我是DS小龙哥-这是一段测试的数据，如果你可以正确的看到我，说明解码已经成功了";
    int freq[MAX_CHAR] = { 0 };

    for (int i = 0; data[i]; i++) {
        freq[(unsigned char)data[i]]++;
    }

    unsigned char uniqueChars[MAX_CHAR];
    int uniqueFreqs[MAX_CHAR];
    int size = 0;

    for (int i = 0; i < MAX_CHAR; i++) {
        if (freq[i]) {
            uniqueChars[size] = i;
            uniqueFreqs[size] = freq[i];
            size++;
        }
    }

    struct MinHeapNode* root = buildHuffmanTree(uniqueChars, uniqueFreqs, size);

    char* codes[MAX_CHAR] = { 0 };
    int arr[MAX_TREE_HT], top = 0;

    generateCodes(root, arr, top, codes);

    printf("Huffman Codes:\n");
    printCodes(codes);

    char compressed[1024] = { 0 };
    compressData(data, codes, compressed);

    printf("\nCompressed Data: %s\n", compressed);

    char decoded[1024] = { 0 };
    decodeHuffmanTree(root, compressed, decoded);

    printf("\nDecoded Data: %s\n", decoded);

    for (int i = 0; i < MAX_CHAR; i++) {
        if (codes[i]) {
            free(codes[i]);
        }
    }

    return 0;
}

这段代码实现了霍夫曼编码算法的压缩和解码功能。霍夫曼编码是一种无损数据压缩算法，利用字符在数据中出现的频率构建霍夫曼树，从而生成字符的二进制编码。

代码先定义了霍夫曼树节点和最小堆的结构，包含创建新节点、交换节点、堆化节点、提取最小值节点、插入最小堆和构建最小堆的功能。然后，通过辅助函数isLeaf检查节点是否为叶子节点。

通过buildHuffmanTree函数构建霍夫曼树，将字符和其对应的频率插入最小堆，反复提取两个最小频率节点，并将它们合并成一个新节点，再插回最小堆，直到堆中只剩一个节点，即为霍夫曼树的根节点。通过generateCodes函数递归遍历霍夫曼树，生成每个字符的霍夫曼编码，并存储在编码表中。

compressData函数使用生成的编码表将输入数据压缩为霍夫曼编码。

decodeHuffmanTree函数通过遍历霍夫曼树解码压缩后的数据，恢复原始数据。

printCodes辅助函数用于打印生成的霍夫曼编码表。

在主函数中，统计输入数据中每个字符的频率，然后构建霍夫曼树，生成编码表，对输入数据进行压缩，最后再对压缩后的数据进行解码，并打印结果。代码在实现霍夫曼编码和解码过程中，展示了从频率统计、树的构建、编码生成到数据压缩和解码的完整流程。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

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

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

相关文章

提升效率必备！学习awk命令，轻松搞定数据

提升效率必备！学习awk命令，轻松搞定数据

在日常的工作中&#xff0c;无论是数据处理、日志分析&#xff0c;还是格式化输出&#xff0c;AWK命令都是不可或缺的利器。AWK是一种强大的文本处理工具&#xff0c;能让你轻松处理复杂的数据&#xff0c;提升工作效率。本文将为你介绍AWK的基本功能及一些实用场景&#xff0c…
阅读更多...
树 --- 二叉树

树 --- 二叉树

树的物理结构和逻辑结构上都是树形结构。 树形结构&#xff1a;由一个根和若干个子节点组成的集合。 最外围的为叶子节点&#xff1a;只有前驱而没有后继。 &#xff08;一&#xff09;树的性质 • ⼦树是不相交的 • 除了根结点外&#xff0c;每个结点有且仅有⼀个⽗结点 •…
阅读更多...
每天五分钟玩转深度学习框架PyTorch：将nn的神经网络层连接起来

每天五分钟玩转深度学习框架PyTorch：将nn的神经网络层连接起来

本文重点 前面我们学习pytorch中已经封装好的神经网络层，有全连接层，激活层，卷积层等等，我们可以直接使用。 如代码所示我们直接使用了两个nn.Linear（），这两个linear之间并没有组合在一起，所以forward的之后，分别调用了，在实际使用中我们常常将几个神经层组合在一起…
阅读更多...
【EI会议征稿通知】第十一届机械工程、材料和自动化技术国际会议（MMEAT 2025）

【EI会议征稿通知】第十一届机械工程、材料和自动化技术国际会议（MMEAT 2025）

第十一届机械工程、材料和自动化技术国际会议&#xff08;MMEAT 2025&#xff09; 2025 11th International Conference on Mechanical Engineering, Materials and Automation Technology 本次大会旨在汇聚全球机械工程、材料科学及自动化技术的创新学者和行业专家&#xff0…
阅读更多...
使用 BentoML快速实现Llama-3推理服务

使用 BentoML快速实现Llama-3推理服务

介绍 近年来&#xff0c;开源大模型如雨后春笋般涌现&#xff0c;为自然语言处理领域带来了革命性的变化。从文本生成到代码编写&#xff0c;从机器翻译到问答系统&#xff0c;开源大模型展现出惊人的能力&#xff0c;吸引了越来越多的开发者和企业投身其中。 然而&#xff0…
阅读更多...
Subclass-balancing Contrastive Learning for Long-tailed Recognition

Subclass-balancing Contrastive Learning for Long-tailed Recognition

文章目录 SCL(supervised contrastive learning)1. 监督对比学习&#xff08;SCL&#xff09;的基本概念2. SCL的损失函数3. 长尾数据集的问题4. k-正样本对比学习&#xff08;KCL&#xff09;的引入5. 总结 SBCL举例说明&#xff1a;狗的分类 关键点&#xff1a;划分为多个子类…
阅读更多...
4-1.Android Camera 之 CameraInfo 编码模板（前后置摄像头理解、摄像头图像的自然方向理解）

4-1.Android Camera 之 CameraInfo 编码模板（前后置摄像头理解、摄像头图像的自然方向理解）

一、Camera.CameraInfo Camera.CameraInfo 是用于获取设备上摄像头信息的一个类&#xff0c;它提供摄像头的各种详细信息&#xff0c;例如&#xff0c;摄像头的方向、是否支持闪光灯等&#xff0c;以下是它的常用属性 static int CAMERA_FACING_BACK&#xff1a;表示设备的后置…
阅读更多...
Protobuf库的使用

Protobuf库的使用

文章目录 Protobuf是什么Protobuf使⽤流程介绍ProtoBuf的使用创建.proto⽂件指定proto3语法package声明符定义消息&#xff08;message&#xff09;编译contacts.proto⽂件命令如下&#xff1a;序列化与反序列化的使⽤ Protobuf是什么 ProtoBuf&#xff08;全称ProtocolBuffer…
阅读更多...
数字 FPV 革命 – DJI、Leadcore 和 Artosyn 的三角关系。

数字 FPV 革命 – DJI、Leadcore 和 Artosyn 的三角关系。

人们对 DJI、Caddx FPV 以及 HDZero 等公司最近推出的数字 FPV 系统的起源进行了大量的猜测和推测。随着 Avatar 系统的发布&#xff0c;也有许多人认为它要么使用与 DJI 相同的芯片组&#xff0c;要么是复制品或克隆品。在本文中&#xff0c;我将尝试揭开这一切的神秘面纱&…
阅读更多...
python spider novel

python spider novel

python msedgedriver 获取小说 声明&#xff1a;只为学习/练习技术 from lxml import etree from selenium import webdriver from selenium.webdriver.edge.service import Service from selenium.webdriver.edge.options import Optionsimport time# 初始化EdgeOptions, 以…
阅读更多...
【系统规划与管理师】【案例分析】【考点】【答案篇】第4章 IT服务规划设计

【系统规划与管理师】【案例分析】【考点】【答案篇】第4章 IT服务规划设计

【问题篇】☞【系统规划与管理师】【案例分析】【考点】【问题篇】第4章 IT服务规划设计 【移动端浏览】☞【系统规划与管理师】【案例分析】【模拟考题】章节考题汇总&#xff08;第4章&#xff09;&#xff08;答案篇&#xff09;&#xff08;共38个知识点&#xff09; 第4章…
阅读更多...
《数字信号处理》学习05-单位冲击响应与系统响应

《数字信号处理》学习05-单位冲击响应与系统响应

目录 一&#xff0c;单位冲激响应 二&#xff0c;LTI系统对任意序列的系统响应 三&#xff0c;LTI系统的性质 通过上一篇文章《数字信号处理》学习04-离散时间系统中的线性时不变系统-CSDN博客的学习&#xff0c;我已经知道了离散时间线性时不变系统&#xff08;LTI&#x…
阅读更多...
基于 jenkins 的持续测试方案

基于 jenkins 的持续测试方案

CI/CD Continuous Integration; Continuous Deployment; 持续集成&#xff0c;将新代码和旧代码一起打包、构建&#xff1b;持续部署&#xff0c;将新构建的包进行部署&#xff1b;持续测试&#xff0c;将新代码、新单元测试一起测试&#xff1b;方案&#xff1a; 公有云DevO…
阅读更多...
Python 控制Chrome浏览器使用Selenium4操作点击百度搜索

Python 控制Chrome浏览器使用Selenium4操作点击百度搜索

前面我们讲到如何安装Selenium和ChromeDriver来驱动打开网页,现在我们有一个目的就是使用python来控制chrome浏览器打开百度并搜索 直接先上调试好的代码 from time import sleepfrom selenium import webdriver from selenium.webdriver.common.keys import Keys from selen…
阅读更多...
2-88 基于matlab的四叉树加权聚焦多聚焦图像融合

2-88 基于matlab的四叉树加权聚焦多聚焦图像融合

基于matlab的四叉树加权聚焦多聚焦图像融合&#xff0c;的四叉树分解策略将源图像被分解成四叉树结构中具有最佳尺寸的块。在这个树形结构中&#xff0c;使用一种新的加权焦点测量方法&#xff08;名为加权修正拉普拉斯之和&#xff09;来检测焦点区域。可以很好地从源图像中提…
阅读更多...
1934. 数字游戏（number）

1934. 数字游戏（number）

代码 #include<bits/stdc.h> using namespace std; int main() {int ans0,i;string s;cin>>s;for(i0;i<7;i)if(s[i]1)ans;cout<<ans;return 0; } 记得点赞关注收藏&#xff01;&#xff01;&#xff01;谢谢&#xff01;&#xff01;&#xff01;
阅读更多...
基于huffman树的文件压缩项目以及相关测试

基于huffman树的文件压缩项目以及相关测试

前言 项目采用Huffman编码的方式进行文件压缩与解压缩。主要原理是通过Huffman编码来表示字符&#xff0c;出现次数多的编码短&#xff0c;出现次数少的编码长&#xff0c;这样整体而言&#xff0c;所需要的bit位是减少的&#xff0c;就实现了文件压缩功能。读取文件中的字符出…
阅读更多...
基于大语言模型智能体的自主机器学习

基于大语言模型智能体的自主机器学习

文章介绍了MLR-Copilot框架&#xff0c;这是一种利用大型语言模型&#xff08;LLMs&#xff09;来自动化机器学习研究中创意生成、实验设计和实施过程的方法。该框架分为三个阶段&#xff1a; 首先通过阅读现有研究文献&#xff0c;使用LLM驱动的IdeaAgent来生成研究假设和实验…
阅读更多...
PADS Router 入门基础教程（一）

PADS Router 入门基础教程（一）

有将近三周没有更新过博客了&#xff0c;最近在整理PADS Router 入门基础教程&#xff0c;希望喜欢本系列教程的小伙伴可以点点关注和订阅&#xff01;下面我们开始进入PADS Router课程的介绍。 一、PADS Router 快捷键 ​ 二、课程介绍 本教程主要介绍&#xff1a;PADS Rou…
阅读更多...
电脑安装Winserver2016无法安装网卡驱动（解决办法）

电脑安装Winserver2016无法安装网卡驱动（解决办法）

因为工作原因&#xff0c;需要找一台PC机作为服务器去测试软件性能问题&#xff0c;故需要在PC机上安装网卡驱动。 电脑品牌&#xff1a;联想 型号&#xff1a;天逸510Pro-18ICB 操作系统&#xff1a;WindowsServer2016&#xff08;桌面版&#xff09; 问题&#xff1a;系统…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023