【信息论与编码】【北京航空航天大学】实验一、哈夫曼编码【C语言实现】（上）

news2024/11/18 11:35:01

信息论与编码 实验1 哈夫曼编码 实验报告

一、运行源代码所需要的依赖：
1、硬件支持

Windows 10，64位系统

在这里插入图片描述

2、编译器

DEV-Redpanda IDE，小熊猫C++

在这里插入图片描述
二、算法实现及测试

1、C语言源程序

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

// 文件数据结构
struct head
{
    int b;						  //字符
    long count;                   //文件中该字符出现的次数
    long parent, lch, rch;        //父、左右子节点，make a tree
    char bits[256];               //存储编码 the huffuman code
};

struct head header[512], tmp;  //节点树

// 函数：printfPercent()
// 作用：输出压缩进度
void printfPercent(int per)
{
	int i = 0;
	printf("|");
	for(i = 0; i < 10; i++)
	{
		if(i < per/10)
			printf(">");
		else
			printf("-");
	}
	printf("|已完成%d%%\n",per);
}

//函数：compress()
//作用：读取文件内容并加以压缩
//将压缩内容写入另一个文档
int compress(const char *filename,const char *outputfile)
{
    char buf[512];
    unsigned char c;
    long i, j, m, n, f;
    long min1, pt1, flength;
    FILE *ifp, *ofp;
	int per = 10;
    ifp = fopen(filename, "rb");                  //打开原始文件
    if (ifp == NULL)
    {
        printf("打开文件失败:%s\n",filename);
        return 0;                             //如果打开失败，则输出错误信息
    }
    ofp = fopen(outputfile,"wb");                 //打开压缩后存储信息的文件
    if (ofp == NULL)
    {
        printf("打开文件失败:%s\n",outputfile);
        return 0;
    }
    fprintf(ofp, "%s", "myzip");
    flength = 0;
    while (!feof(ifp))
    {
        fread(&c, 1, 1, ifp);
        header[c].count ++;                       //读文件，统计字符出现次数
        flength ++;                               //记录文件的字符总数
    }
    flength --;
    header[c].count --;
    for (i = 0; i < 512; i ++)                    //HUFFMAN算法中初始节点的设置
    {
        if (header[i].count != 0)
            header[i].b = (unsigned char) i;
        else
            header[i].b = -1;
        header[i].parent = -1;
        header[i].lch = header[i].rch = -1;
    }
 
    for (i = 0; i < 256; i ++)                    //将节点按出现次数排序
    {
        for (j = i + 1; j < 256; j ++)
        {
            if (header[i].count < header[j].count)
            {
                tmp = header[i];
                header[i] = header[j];
                header[j] = tmp;
            }
        }
    }
 
 
    for (i = 0; i < 256; i ++)                    //统计不同字符的数量
	{
        if (header[i].count == 0)
            break;
	}
 
    n = i;
    m = 2 * n - 1;
    for (i = n; i < m; i ++)
    {
        min1 = 999999999;
        for (j = 0; j < i; j ++)
        {
            if (header[j].parent != -1) continue;
            if (min1 > header[j].count)
            {
                pt1 = j;
                min1 = header[j].count;
                continue;
            }
        }
        header[i].count = header[pt1].count;
        header[pt1].parent = i;
        header[i].lch = pt1;
        min1 = 999999999;
        for (j = 0; j < i; j ++)
        {
            if (header[j].parent != -1) continue;
            if (min1 > header[j].count)
            {
                pt1 = j;
                min1 = header[j].count;
                continue;
            }
        }
        header[i].count += header[pt1].count;
        header[i].rch = pt1;
        header[pt1].parent = i;
    }
 
    for (i = 0; i < n; i ++)                        //构造HUFFMAN树，设置字符的编码
    {
        f = i;
        header[i].bits[0] = 0;
        while (header[f].parent != -1)
        {
            j = f;
            f = header[f].parent;
            if (header[f].lch == j)
            {
                j = strlen(header[i].bits);
                memmove(header[i].bits + 1, header[i].bits, j + 1);
                header[i].bits[0] = '0';
            }
            else
            {
                j = strlen(header[i].bits);
                memmove(header[i].bits + 1, header[i].bits, j + 1);
                header[i].bits[0] = '1';
            }
        }
    }
 
    //下面的就是读原文件的每一个字符，按照设置好的编码替换文件中的字符
    fseek(ifp, 0, SEEK_SET);                                                //将指针定在文件起始位置
    fseek(ofp, 8, SEEK_SET);                                //以8位二进制数为单位进行读取
    buf[0] = 0;
    f = 0;
    pt1 = 8;
 
	printf("读取将要压缩的文件:%s\n",filename);
	printf("当前文件有:%d字符\n",flength);
	if(flength == 0){
		printf("警告：该文件为空\n");
		return 0; 
	}
	printf("正在压缩\n");
 
    while (!feof(ifp))
    {
        c = fgetc(ifp);
        f ++;
        for (i = 0; i < n; i ++)
        {
            if (c == header[i].b) break;
        }
        strcat(buf, header[i].bits);
        j = strlen(buf);
        c = 0;
        while (j >= 8)                                             //当剩余字符数量不小于8个时
        {
            for (i = 0; i < 8; i ++)                               //按照八位二进制数转化成十进制ASCII码写入文件一次进行压缩
            {
                if (buf[i] == '1') c = (c << 1) | 1;
                else c = c << 1;
            }
            fwrite(&c, 1, 1, ofp);
            pt1 ++;
            strcpy(buf, buf + 8);
            j = strlen(buf);
        }
		if(100 * f/flength > per)
		{
			printfPercent(per);
			per += 10;
		}
        if (f == flength)
			break;
    }
	printfPercent(100);
 
    if (j > 0)                                                      //当剩余字符数量少于8个时
    {
        strcat(buf, "00000000");
        for (i = 0; i < 8; i ++)
        {
            if (buf[i] == '1') c = (c << 1) | 1;
            else c = c << 1;                                        //对不足的位数进行补零
        }
        fwrite(&c, 1, 1, ofp);
        pt1 ++;
    }
    fseek(ofp, 0, SEEK_SET);                                        //将编码信息写入存储文件
	fwrite(&flength,1,sizeof(flength),ofp);
    fwrite(&pt1, sizeof(long), 1, ofp);
    fseek(ofp, pt1, SEEK_SET);
    fwrite(&n, sizeof(long), 1, ofp);
    for (i = 0; i < n; i ++)
    {
		tmp = header[i];
 
        fwrite(&(header[i].b), 1, 1, ofp);
		pt1++;
        c = strlen(header[i].bits);
        fwrite(&c, 1, 1, ofp);
		pt1++;
        j = strlen(header[i].bits);
 
        if (j % 8 != 0)                                             //当位数不满8时，对该数进行补零操作
        {
            for (f = j % 8; f < 8; f ++)
                strcat(header[i].bits, "0");
        }
 
        while (header[i].bits[0] != 0)
        {
            c = 0;
            for (j = 0; j < 8; j ++)
            {
                if (header[i].bits[j] == '1') c = (c << 1) | 1;
                else c = c << 1;
            }
            strcpy(header[i].bits, header[i].bits + 8);
            fwrite(&c, 1, 1, ofp);                                            //将所得的编码信息写入文件
			pt1++;
        }
 
		header[i] = tmp;
    }
    fclose(ifp);
    fclose(ofp);                                                              //关闭文件
 
	printf("压缩后文件为:%s\n",outputfile);
    printf("压缩后文件有:%d字符\n",pt1 + 4);
 
    return 1;                                       //返回压缩成功信息
}

//函数：compress()
//作用：读取文件内容并加以压缩
//将压缩内容写入另一个文档
int compress(const char *filename,const char *outputfile)
{
    char buf[512];
    unsigned char c;
    long i, j, m, n, f;
    long min1, pt1, flength;
    FILE *ifp, *ofp;
	int per = 10;
    ifp = fopen(filename, "rb");                  //打开原始文件
    if (ifp == NULL)
    {
        printf("打开文件失败:%s\n",filename);
        return 0;                             //如果打开失败，则输出错误信息
    }
    ofp = fopen(outputfile,"wb");                 //打开压缩后存储信息的文件
    if (ofp == NULL)
    {
        printf("打开文件失败:%s\n",outputfile);
        return 0;
    }
    fprintf(ofp, "%s", "myzip");
    flength = 0;
    while (!feof(ifp))
    {
        fread(&c, 1, 1, ifp);
        header[c].count ++;                       //读文件，统计字符出现次数
        flength ++;                               //记录文件的字符总数
    }
    flength --;
    header[c].count --;
    for (i = 0; i < 512; i ++)                    //HUFFMAN算法中初始节点的设置
    {
        if (header[i].count != 0)
            header[i].b = (unsigned char) i;
        else
            header[i].b = -1;
        header[i].parent = -1;
        header[i].lch = header[i].rch = -1;
    }
 
    for (i = 0; i < 256; i ++)                    //将节点按出现次数排序
    {
        for (j = i + 1; j < 256; j ++)
        {
            if (header[i].count < header[j].count)
            {
                tmp = header[i];
                header[i] = header[j];
                header[j] = tmp;
            }
        }
    }
 
 
    for (i = 0; i < 256; i ++)                    //统计不同字符的数量
	{
        if (header[i].count == 0)
            break;
	}
 
    n = i;
    m = 2 * n - 1;
    for (i = n; i < m; i ++)
    {
        min1 = 999999999;
        for (j = 0; j < i; j ++)
        {
            if (header[j].parent != -1) continue;
            if (min1 > header[j].count)
            {
                pt1 = j;
                min1 = header[j].count;
                continue;
            }
        }
        header[i].count = header[pt1].count;
        header[pt1].parent = i;
        header[i].lch = pt1;
        min1 = 999999999;
        for (j = 0; j < i; j ++)
        {
            if (header[j].parent != -1) continue;
            if (min1 > header[j].count)
            {
                pt1 = j;
                min1 = header[j].count;
                continue;
            }
        }
        header[i].count += header[pt1].count;
        header[i].rch = pt1;
        header[pt1].parent = i;
    }
 
    for (i = 0; i < n; i ++)                        //构造HUFFMAN树，设置字符的编码
    {
        f = i;
        header[i].bits[0] = 0;
        while (header[f].parent != -1)
        {
            j = f;
            f = header[f].parent;
            if (header[f].lch == j)
            {
                j = strlen(header[i].bits);
                memmove(header[i].bits + 1, header[i].bits, j + 1);
                header[i].bits[0] = '0';
            }
            else
            {
                j = strlen(header[i].bits);
                memmove(header[i].bits + 1, header[i].bits, j + 1);
                header[i].bits[0] = '1';
            }
        }
    }
 
    //下面的就是读原文件的每一个字符，按照设置好的编码替换文件中的字符
    fseek(ifp, 0, SEEK_SET);                                                //将指针定在文件起始位置
    fseek(ofp, 8, SEEK_SET);                                //以8位二进制数为单位进行读取
    buf[0] = 0;
    f = 0;
    pt1 = 8;
 
	printf("读取将要压缩的文件:%s\n",filename);
	printf("当前文件有:%d字符\n",flength);
	if(flength == 0){
		printf("警告：该文件为空\n");
		return 0; 
	}
	printf("正在压缩\n");
 
    while (!feof(ifp))
    {
        c = fgetc(ifp);
        f ++;
        for (i = 0; i < n; i ++)
        {
            if (c == header[i].b) break;
        }
        strcat(buf, header[i].bits);
        j = strlen(buf);
        c = 0;
        while (j >= 8)                                             //当剩余字符数量不小于8个时
        {
            for (i = 0; i < 8; i ++)                               //按照八位二进制数转化成十进制ASCII码写入文件一次进行压缩
            {
                if (buf[i] == '1') c = (c << 1) | 1;
                else c = c << 1;
            }
            fwrite(&c, 1, 1, ofp);
            pt1 ++;
            strcpy(buf, buf + 8);
            j = strlen(buf);
        }
		if(100 * f/flength > per)
		{
			printfPercent(per);
			per += 10;
		}
        if (f == flength)
			break;
    }
	printfPercent(100);
 
    if (j > 0)                                                      //当剩余字符数量少于8个时
    {
        strcat(buf, "00000000");
        for (i = 0; i < 8; i ++)
        {
            if (buf[i] == '1') c = (c << 1) | 1;
            else c = c << 1;                                        //对不足的位数进行补零
        }
        fwrite(&c, 1, 1, ofp);
        pt1 ++;
    }
    fseek(ofp, 0, SEEK_SET);                                        //将编码信息写入存储文件
	fwrite(&flength,1,sizeof(flength),ofp);
    fwrite(&pt1, sizeof(long), 1, ofp);
    fseek(ofp, pt1, SEEK_SET);
    fwrite(&n, sizeof(long), 1, ofp);
    for (i = 0; i < n; i ++)
    {
		tmp = header[i];
 
        fwrite(&(header[i].b), 1, 1, ofp);
		pt1++;
        c = strlen(header[i].bits);
        fwrite(&c, 1, 1, ofp);
		pt1++;
        j = strlen(header[i].bits);
 
        if (j % 8 != 0)                                             //当位数不满8时，对该数进行补零操作
        {
            for (f = j % 8; f < 8; f ++)
                strcat(header[i].bits, "0");
        }
 
        while (header[i].bits[0] != 0)
        {
            c = 0;
            for (j = 0; j < 8; j ++)
            {
                if (header[i].bits[j] == '1') c = (c << 1) | 1;
                else c = c << 1;
            }
            strcpy(header[i].bits, header[i].bits + 8);
            fwrite(&c, 1, 1, ofp);                                            //将所得的编码信息写入文件
			pt1++;
        }
 
		header[i] = tmp;
    }
    fclose(ifp);
    fclose(ofp);                                                              //关闭文件
 
	printf("压缩后文件为:%s\n",outputfile);
    printf("压缩后文件有:%d字符\n",pt1 + 4);
 
    return 1;                                       //返回压缩成功信息
}

// 主函数
int main(int argc,const char *argv[])
{
	memset(&header,0,sizeof(header));
    memset(&tmp,0,sizeof(tmp));
    char tmpname[100] = { 0 };
    char filename[100] = { 0 };
    char zipname[100] = { 0 };
    char recovername[100] = { 0 };
    //用户接口部分
	printf("------------欢迎使用本文件压缩程序，按任意键开始------------\n");
	system("pause");
	printf("------------请在下方输入你想要压缩的文件名------------\n");
	scanf("%s", tmpname);
	strcpy(filename, tmpname);
	strcat(tmpname, ".zip");
	strcpy(zipname, tmpname);
	printf("-----------压缩开始，请稍等片刻-----------\n");
	compress(filename,zipname);
	strcat(tmpname, "解压后.txt"); 
	strcpy(recovername, tmpname);
	uncompress(zipname,recovername);
	system("pause");
 
	return 0;
}

2、算法性能测试

（1）测试文件1：article1.txt
文件说明：普通英文文档，取自英国小说《哈利·波特》的一个章节
文件截图：
在这里插入图片描述

运行时截图：

在这里插入图片描述

（2）测试文件2：singlebyte.txt

文件说明：只含一种字节（字母a）
文件截图：
在这里插入图片描述
运行时截图：

在这里插入图片描述

（3）测试文件3：empty.txt

文件说明：空文本文件，大小为0KB。

运行时截图：

在这里插入图片描述

三、实践性问题

1、重复性的文件结构

使用你在必选模组实现的程序，编码 lab1_data/testfile1，lab1_data/testfile1 的文件内容是：256 字节 0x00，256 字节 0x01，256 字节 0x02，…，256 字节 0xff，总计 64 KiB。观察编码后的文件大小，解释为什么文件体积会发生这种变化（为什么会这样（模组 1 和 模组 3） / 是什么发挥了作用（模组 2））。

解答：

文件名称：testfile1.txt
压缩前大小：65536字节（64KB）
压缩后大小：66249字节（65KB）
压缩比例：101.6%
原文件SHA256值：
c3e145bc3d6790dab078e628cf8530b565c30aac7b5c70fd100b67651d064ad4
压缩后文件SHA256值：
23321562a0a3a4d891de297dade09c3ab0794d3e222dc8a08206429f0dd59e8a
解压缩后文件SHA256值：
c3e145bc3d6790dab078e628cf8530b565c30aac7b5c70fd100b67651d064ad4
运行时截图：

在这里插入图片描述

现象：压缩比例大于1，即压缩后的文件比压缩前的文件更大。
对该现象的解释：对于testfile1.txt中的字符，即0x00, 0x01, 0x02, …0xff共计256种字节，每种字节出现的概率相同，所生成的哈夫曼树为一棵极不平衡的二叉树，形如下图：
在这里插入图片描述

其中，256种字节（与顺序无关）分别被编码成码长为1，2，3，4，5，……255，255（单位为bit）共256个码元。故压缩后的文件大小为256 * （1 + 2 + 3 + 4 + 5 + …… + 255 + 255）= 256 * 255 * 129 bits。原文件大小为64KB = 64 * 2^10 * 8 = 2^19 bits. 可见，压缩后的文件体积比压缩前的文件体积更大。

2、“黑洞”来了？

问： 如果我将一个超大的文件压缩几百次，他就会变得越来越小，最后达到几 KB，这便是时间换空间！这种说法正确吗？
答： 这种说法不正确。
实践题： 对给定的 bmp 格式图片迭代地编码 10 次，观察压缩结果的体积变化。为什么会发生这种变化？结合你学过的知识解答。
答： 压缩结果的体积变化如下表所示：
第n次压缩 压缩前大小（KB） 压缩后大小（KB）
1 24301 3687
2 3687 1069
3 1069 791
4 791 773
5 773 781
6 781 792
7 792 803
8 803 814
9 814 826
10 826 837
被压缩的文件截图：
在这里插入图片描述

现象： 从第3次压缩操作之后，文件体积基本上没有变化，从第5次压缩操作开始，反而表现出越压缩，文件体积越大。
对该现象的解释： 香农Shannon信息论中的信息熵。熵界的存在性，导致文件不可能被压缩至 “无限小” （单个比特），所谓的 “文件黑洞” 违背信息论。

至此，本次实验结束。

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

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

相关文章

江山易改本性难移之ZYNQ SDK FSBL加载启动代码详解

江山易改本性难移之ZYNQ SDK FSBL加载启动代码详解

SDK版本&#xff1a;2018.3 写在前面&#xff1a; 该文档不足以使你清楚FSBL启动的寄存器级的操作细节&#xff0c;但可以让你看明白整个ZYNQ7000 FSBL代码执行的主要流程。 1. ZYNQ7000加载启动流程 &#xff08;1&#xff09;BootRom阶段为ARM上电后最早加载的代码&#x…
阅读更多...
朋友圈的批量发送，定时发送，极大的提工作高效率，解放员工时间和精力，从而降本增效！

朋友圈的批量发送，定时发送，极大的提工作高效率，解放员工时间和精力，从而降本增效！

阅读更多...
Android SDK环境搭建

Android SDK环境搭建

一、Android SDK简介 SDK&#xff1a;&#xff08;software development kit&#xff09;软件开发工具包。被软件开发工程师用于为特定的软件包、软件框架、硬件平台、操作系统等建立应用软件的开发工具的集合。 因此&#xff0c;Android SDK 指的是Android专属的软件…
阅读更多...
【Scala】——函数式编程

【Scala】——函数式编程

1 面向对象编程和函数式编程 1.1 面向对象编程 解决问题&#xff0c;分解对象&#xff0c;行为&#xff0c;属性&#xff0c;然后通过对象的关系以及行为的调用来解决问题。 • 对象&#xff1a;用户 • 行为&#xff1a;登录、连接 JDBC、读取数据库 • 属性&#xff1a;用户…
阅读更多...
内裤洗衣机有用吗？五款小型洗衣机全自动推荐

内裤洗衣机有用吗？五款小型洗衣机全自动推荐

随着内衣洗衣机的流行&#xff0c;很多小伙伴在纠结该不该入手一款内衣洗衣机&#xff0c;专门来洗一些贴身衣物&#xff0c;答案是非常有必要的&#xff0c;因为我们现在市面上的大型洗衣机只能做清洁&#xff0c;无法对我们的贴身衣物进行一个高强度的清洁&#xff0c;而小小…
阅读更多...
Linux运维之切换到 root 用户

Linux运维之切换到 root 用户

春花秋月何时了，往事知多少。此付费专栏不要订阅，不要订阅，听人劝。 🌹作者主页：青花锁 🌹简介：Java领域优质创作者🏆、Java微服务架构公号作者😄 🌹简历模板、学习资料、面试题库、技术互助 🌹文末获取联系方式 📝 系列专栏目录 [Java项目实战] 介绍Java…
阅读更多...
C/C++ 位段

C/C++ 位段

目录 什么是位段&#xff1f; 位段的内存分配 位段的跨平台问题 什么是位段&#xff1f; 位段的声明与结构是类似的&#xff0c;但是有两个不同&#xff1a; 位段的成员必须是 int、unsigned int 或signed int 等整型家族。位段的成员名后边有一个冒号和一个数字 这是一个…
阅读更多...
JPEG格式详解Baseline、Progressive的区别

JPEG格式详解Baseline、Progressive的区别

文章目录 JPEG的简介压缩质量/压缩比率色彩空间基线和渐进子采样存储选项 基线和渐进基线格式渐进格式&#xff1a; 子采样4:4:4&#xff08;无损&#xff09;4:2:24:2:0 JPEG的简介 JPEG&#xff08;Joint Photographic Experts Group&#xff09;是一种常见的图像压缩格式&a…
阅读更多...
K8S 存储卷

K8S 存储卷

意义&#xff1a;存储卷----数据卷 容器内的目录和宿主机的目录进行挂载 容器在系统上的生命周期是短暂的&#xff0c;delete,k8s用控制器创建的pod&#xff0c;delete相当于重启&#xff0c;容器的状态也会回复到初始状态 一旦回到初始状态&#xff0c;所有的后天编辑的文件…
阅读更多...
原来这些小众知识库软件这么好用，挖到宝了

原来这些小众知识库软件这么好用，挖到宝了

在企业管理中&#xff0c;知识库的作用越来越被重视。它不仅可以提高工作流程的效率&#xff0c;还可以最大限度地利用企业中的知识资源。然而&#xff0c;在众多的知识库工具中选择一款合适的并非易事。不用担心&#xff0c;今天我要为大家揭晓一些小众却非常好用的知识库软件…
阅读更多...
C语言之详解数组【附三子棋和扫雷游戏实战】

C语言之详解数组【附三子棋和扫雷游戏实战】

文章目录 一、一维数组的创建和初始化1、数组的创建2、数组的初始化3、一维数组的使用4、 一维数组在内存中的存储 二、二维数组的创建和初始化1、二维数组的创建2、二维数组的初始化3、二维数组的使用4、二维数组在内存中的存储 三、数组越界边界值考虑不当导致越界访问数组大…
阅读更多...
如何利用CHAT做简单的总结体会？

如何利用CHAT做简单的总结体会？

问CHAT &#xff1a;在测试过程中使用appiumpython自动化的优点和体会 CHAT回复&#xff1a;使用 Appium 配合 Python 进行自动化测试主要有以下几点优点&#xff1a; 1. 跨平台性&#xff1a;Appium 支持 iOS 和 Android 平台的应用自动化测试&#xff0c;无论是原生应用、移…
阅读更多...
开放平台系统架构设计

开放平台系统架构设计

一、概述 背景与目标 本开放平台旨在构建一个可扩展、高可用的生态体系&#xff0c;通过提供统一标准的API接口和SDK工具包&#xff0c;让第三方开发者能够安全、高效地接入我们的服务和资源&#xff0c;实现业务的互联互通。 定位与功能描述 系统主要包含用户认证授权、资…
阅读更多...
[C#]winform部署PaddleOCRV3推理模型

[C#]winform部署PaddleOCRV3推理模型

【官方框架地址】 https://github.com/PaddlePaddle/PaddleOCR.git 【算法介绍】 PaddleOCR是由百度公司推出的一款开源光学字符识别&#xff08;OCR&#xff09;工具&#xff0c;它基于深度学习框架PaddlePaddle开发。这款工具提供了一整套端到端的文字检测和识别解决方案&a…
阅读更多...
OpenHarmony之hdc

OpenHarmony之hdc

OpenHarmony之hdc 简介 hdc&#xff08;OpenHarmony Device Connector&#xff09;是 OpenHarmony 为开发人员提供的用于调试的命令行工具&#xff0c;通过该工具可以在Windows/Linux/MacOS等系统上与开发机或者模拟器进行交互。 类似于Android的adb&#xff0c;和adb类似&a…
阅读更多...
如何使用web文件管理器Net2FTP搭建个人网盘

如何使用web文件管理器Net2FTP搭建个人网盘

文章目录 1.前言2. Net2FTP网站搭建2.1. Net2FTP下载和安装2.2. Net2FTP网页测试 3. cpolar内网穿透3.1.Cpolar云端设置3.2.Cpolar本地设置 4.公网访问测试5.结语 1.前言 文件传输可以说是互联网最主要的应用之一&#xff0c;特别是智能设备的大面积使用&#xff0c;无论是个人…
阅读更多...
智能时代：自然语言生成SQL与知识图谱问答实战

智能时代：自然语言生成SQL与知识图谱问答实战

语义解析 前言语义解析的应用场景总结概论语义解析和大模型的关系延伸阅读 前言 语义解析技术可以提高人机交互的效率和准确性&#xff0c;在自然语言处理、数据分析、智能客服、智能家居等领域都有广泛的应用前景。特别是在大数据时代&#xff0c;语义解析能够帮助企业更快速…
阅读更多...
pc下载apk文件到andriod开发板，并实现可视化

pc下载apk文件到andriod开发板，并实现可视化

PC端安装APK下载器 点击下载 刷机精灵APK安装器 界面如下&#xff0c;可将下载好的apk文件&#xff0c;直接拖拽到该界面&#xff0c;然后点击安装全部按钮进行安装&#xff0c;安装过程中的具体状态会显示在具体的apk后面。 如下图&#xff0c;安装错误、安装完成等皆为apk安…
阅读更多...
springcloud Config配置中心

springcloud Config配置中心

简介 服务意味着要将单体应用中的业务拆分成一个个子服务&#xff0c;每个服务的粒度相对较小&#xff0c;因此系统中会出现大量的服务。由于每个服务都需要必要的配置信息才能运行&#xff0c;所以一套集中式的、动态的配置管理设施是必不可少的。 SpringCloud提供了ConfigS…
阅读更多...
什么软件能查出微信聊天记录

什么软件能查出微信聊天记录

在企业管理中&#xff0c;很多时候是需要查出员工的具体的聊天记录的。今天就分享两种可以查出微信聊天记录的工具&#xff1a; 工具一&#xff1a;微信自带的工具 1、打开微信&#xff0c;在聊天界面点击右上角的“...”按钮&#xff0c;选择“设置”&#xff0c;进入“聊天”…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023