自写项目——哈夫曼编译码及客户端服务端交互实现

最新推荐文章于 2019-12-02 01:36:55 发布
最新推荐文章于 2019-12-02 01:36:55 发布
阅读量1.3k 收藏
点赞数
分类专栏： 自写小项目 LinuxC 文章标签： hafftree haffman LinuxC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chudongfang2015/article/details/51991649
版权

1.项目要求


哈夫曼编译码

题目要求：编写一个用哈夫曼实现的编码压缩器，语言不限！

实现英文字符编译码的功能；实现译码的压缩解压功能；要有较美观的图形用户界面；从客户端发送一段字符给服务器端，服务器端能成功的返回这段字符经过哈夫曼编译码之后的结果！

编写步骤:

①编写较美观的图形用户界面；

     ②得到客户端所发送的字符信息，并进行统计，每个字符 的频度作为哈夫曼树叶子结点的权值，并构建哈夫曼树；

③进行哈夫曼树的编码和译码；

④自行选取5~7个二进制码来进行压缩；

⑤将压缩好的字符发送到服务器端，并接受；

⑥解压----译码-----编码-----还原成原来的字符！

 

2.项目实现

直接上代码（其中有详细注释，ubuntu 16.04 编译通过！）：


clien.cpp


#include <stdio.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#define BUFFER_SIZE 1024


#define MaxValue 10000//权值最大值 
#define MaxBit 55//最大编码位数 
#define MaxN 55//最大结点个数 

//准备工作
int sockfd;//
char* IP = "127.0.0.1";//该地址请写测试服务器的IP，本机IP,回送地
short PORT = 10222;//端口号
typedef struct sockaddr SA;//类型转换
char message[100];
char demessge[100];






void init()
{
    printf("客户端开始启动\n");
    sockfd = socket(AF_INET,SOCK_STREAM,0);//启动socket
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = inet_addr(IP);
    if(connect(sockfd,(SA*)&addr,sizeof(addr))==-1){//向服务器请求建立链接
        perror("无法连接到服务器");
        printf("客户端启动失败\n");
        exit(-1);
    }
    printf("客户端启动成功\n");
}
//开始通信

void code(int * count)
{
    int t;
    printf("\nplease input message:");
    scanf("%s",message);
    send(sockfd,message,sizeof(message),0);// 把文件大小数据发送
    recv(sockfd,count,sizeof(int),0);//得到编码后的结果大小
    printf("\nthe result:\n");
    for(int i=0;i<*count;i++)
    {
        recv(sockfd,&t,sizeof(int),0);//一个一个接受，并输出
        if(t == 2) 
            printf(" ");
        else
            printf("%d",t);
    }  
    getchar();
    getchar();
}

void decode()
{
    char result[100];
    printf("\nplease input the message you want tanslate:");
    scanf("%s",demessge);//得到要译的码
    send(sockfd,demessge,sizeof(demessge),0);//发送到服务端
    recv(sockfd,result,sizeof(result),0);//从服务端接受到译码后的结果
    printf("\nthe result:\n");
    printf("%s",result);
    getchar();
    getchar();
}








void start()
{
    int count=0;
    char result[100];
    int choice=1;
    int judge;
   //菜单
    do{
        judge=1;
        printf("\n\t********************************************\n");
        printf("\t**            1.字符压缩                    **\n");
        printf("\t**            2.字符解压                    **\n");
        printf("\t**            0.退出                        **\n");
        printf("\t********************************************\n");
        printf("\t请选择:");
        scanf("%d",&choice);
        
        if(choice == 1||choice == 0||choice == 2)
            send(sockfd,&choice,sizeof(int),0);//发送用户选择信息
        else  
            continue;
        
        
        recv(sockfd,&judge,sizeof(int),0);//接受判断标准，判断其是否为错误
        


        if(judge==1) {//如果错误，提示先用1选项建树
            printf("there is no haffe tree! \nplease set up the tree first!\n");
            continue;
        }
        

        switch(choice)
        {
            case 1 :
                code(&count);//编码
                break;
            case 2 :
                decode();//译码
                break;
            default:
                break;
        }
    }while(choice != 0);



    close(sockfd);//关闭socket
}




void sig_close(int i)
{
    //关闭客户端的描述符
    close(sockfd);
    exit(0);
}


int main()
{
    int type;
    signal(SIGINT,sig_close);//关闭CTRL+C
    init();//启动并连接服务器
    start();//开始与服务器进行通信。
    return 0;
}


server.cpp


#include <stdio.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>

#define MaxValue 10000//权值最大值 
#define MaxBit 55//最大编码位数 
#define MaxN 55//最大结点个数 

char message[100];
//准备工作

int sockfd;//
char* IP = "127.0.0.1";//服务器IP
short PORT = 10222;//端口号
typedef struct sockaddr SA;//类型转换


/*====================================
=1.构造哈夫曼树 
=2.构造哈夫曼编码  
=3.构造哈夫曼解码 
====================================*/

//哈夫曼树的结点结构 
typedef struct
{
	char wei;
	int weight;//权值 
	int flag;//标记 
	int parent;// 双亲结点下一标 
	int leftChild;//左孩子下标 
	int rightChild;//右孩子下标 
 } HaffNode;
 
 //哈夫曼编码结构
typedef struct
{
 	int bit[MaxN];//存放哈夫曼编码的数组 
 	int start;//编码的起始下标 
 	int weight;//字符权值 
 }Code;
typedef struct
{
	char ch;
	int  weight;
}STR;

int sear_weight(char ch[],int weight[],char ch2[])
{
	 STR str[27]={{' ',183},{'a',64},{'b',13},{'c',22},{'d',32},{'e',103},
	             {'f',21},{'g',15},{'h',47},{'i',57},{'j',1},{'k',5},
				 {'l',32},{'m',20},{'n',57},{'o',63},{'p',15},{'q',1},
				 {'r',48},{'s',51},{'t',80},{'u',23},{'v',8},{'w',18},
				 {'x',1},{'y',16},{'z',1}};
	int i,k=0;
	
	for(i=0;ch[i]!='\0';i++)
	{
		if(ch[i]==' ')
		{
		    ch2[i]=' ';
		    weight[i]=183;
		}
		else if(ch[i]>=65&&ch[i]<=90)
		{
			k=ch[i];
			ch2[i]=ch[i];
			weight[i]=str[k-64].weight;
		}
		else if(ch[i]>=97&&ch[i]<=122)
		{
			k=ch[i];
			ch2[i]=ch[i];
			weight[i]=str[k-96].weight;
		}
		else 
		{
			return 1; 
		}
	}
}

  // 建立叶节点个数为n,权值数组为weight的哈夫曼树
void HaffTree(int weight[],int n,HaffNode haffTree[],char ch2[])
{
  	int i,j,m1,m2,x1,x2;
  	
  	//初始化哈夫曼树，n个叶结点的二叉树共有2n-1个结点
	for(i=0; i<2*n-1; i++)
	{
	  	if(i<n) 
		{
		  haffTree[i].wei=ch2[i];
		  haffTree[i].weight = weight[i];//叶节点 
		} 
	  	else haffTree[i].weight = 0;//非叶结点
	  	
	  	haffTree[i].parent      = -1;
	  	haffTree[i].flag        = 0;//是否加入二叉树
		haffTree[i].leftChild   = -1;
		haffTree[i].rightChild  = -1;
	}
	   
	//构造哈夫曼树haffTree的n-1个非叶结点
	for(i=0; i<n-1; i++)
	{
		m1=m2=MaxValue;
		x1=x2=0;
		for(j=0; j<n+i; j++)
		{
			if(haffTree[j].weight<=m1 && haffTree[j].flag==0)
			{
			  	m2=m1;
			  	x2=x1;
			  	m1=haffTree[j].weight;
			  	x1=j;
			}
			else if(haffTree[j].weight<=m2 && haffTree[j].flag==0)
			{
				m2=haffTree[i].weight;
				x2=j; 
			}
	    }	  
		//将找出的两棵权值最小的子树合并为一棵子树
		haffTree[x1].parent=n+i;
		haffTree[x2].parent=n+i;
		haffTree[x1].flag=1;
		haffTree[x2].flag=1;
		haffTree[n+i].weight=haffTree[x1].weight+haffTree[x2].weight;
		haffTree[n+i].leftChild=x1;
		haffTree[n+i].rightChild=x2; 
    } 
}  


//由n个结点的哈夫曼树->构造哈夫曼编码 
void HaffCode(HaffNode haffTree[],int n,Code haffCode[])
{
	Code *cd = (Code *)malloc(sizeof(Code));
	int i,j,child,parent;
			
	//求n个叶结点的哈夫曼编码
	for(i=0; i<n; i++)
	{
	    cd->start = n-1;//权值越小，编码越长
		cd->weight=haffTree[i].weight;
		child=i;//从小到大依次编码 
		parent=haffTree[child].parent;
		//刨根问底->从叶结点沿路直到根结点
		while(parent !=-1)//-1根结点
		{
			if(haffTree[parent].leftChild==child)
				cd->bit[cd->start]=0;
			else 
				cd->bit[cd->start]=1;
				   
			cd->start--;//从后往前依次填码
			child=parent;
			parent=haffTree[child].parent; 
		} 
		//保存每个叶结点的信息
		for(j=cd->start+1; j<n; j++)
			haffCode[i].bit[j]=cd->bit[j];//编码
		haffCode[i].start=cd->start+1;//编码起始位 
		haffCode[i].weight=cd->weight;//权值 
		
		
	} 		  
}



void haffyima(HaffNode haffTree[],int n,char demessage[],int weight[],char message[])
{
	int i,j,k=0;
	HaffNode haffTree1;
    int len=strlen(demessage);
	for(i=0;i<len;i++)
	{
		haffTree1=haffTree[2*n-2];

		for(;i<len;i++)
		{   
			if(demessage[i]=='1')
			{
				haffTree1=haffTree[haffTree1.rightChild];
			}
			else 
				haffTree1=haffTree[haffTree1.leftChild];
            if(haffTree1.rightChild == -1 && haffTree1.leftChild == -1)
                break;
		}
		for(j=0;j<n;j++)
		{
		    if(haffTree1.weight==weight[j])
		    {
                message[k++]=haffTree1.wei;
		        break;
            }
		}
	}
}   

 




//初始化服务器的网络,创建socket
void init()
{
    printf("服务器开始启动..\n");
    sockfd = socket(AF_INET,SOCK_STREAM,0);//启动socket
    if(sockfd == -1){
        perror("创建socket失败");
        printf("服务器启动失败\n");
        exit(-1);
    }
    //准备网络通信地址
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = inet_addr(IP);
    if(bind(sockfd,(SA*)&addr,sizeof(addr))==-1){//绑定服务器
        perror("绑定失败");
        printf("服务器启动失败\n");
        exit(-1);
    }
    printf("成功绑定\n");

    //设置监听
    if(listen(sockfd,10)==-1){
        perror("设置监听失败");
        printf("服务器启动失败\n");
        exit(-1);
    }
    printf("设置监听成功\n");
    printf("初始化服务器成功\n");
    //等待客户端链接，放到另一个函数中
}



void* service_thread(void* p)
{
	
	int fd = *(int*)p;          //拿到标记客户端的sockfd  
	int count=0;
    int i,j,n;
    int weight[100]={0};
    char ch[100];
    char ch2[100];
    int cht;
    char demessage[100];
    int choice;
    int flag=0;
    int judge;

	HaffNode *myHaffTree=NULL;
	Code     *myHaffCode=NULL;
    while(1)// 死循环，等待客户端信息
    {
        recv(fd,&choice,sizeof(int),0);//得到客户端选择信息

        if(flag == 0 && choice == 2){//如果其还没建立haff树，则返回错误，提醒其建立haff树
        	judge=1;
        	send(fd,&judge,sizeof(int),0);//返回错误标志
            continue;
        }else{
        	judge=0;
        	send(fd,&judge,sizeof(int),0);
        }

        if(choice == 1)//如果是编码，建立haff树，并编码
        {
            count = 0 ;
        	flag=1;
            recv(fd,ch,sizeof(ch),0);
            n=strlen(ch);//输入编码长度
            sear_weight(ch,weight,ch2);//计算权重

	
	        if(n>MaxN)
	    	{
		   		printf("n越界!!!\n");
	    		return 0;
    		}
	 
            //建树
	  		myHaffTree=(HaffNode *)malloc(sizeof(HaffNode)*(2*n-1));
	        myHaffCode=(Code *)malloc(sizeof(Code)*n);
	    	
	    	HaffTree(weight,n,myHaffTree,ch2);
	    	HaffCode(myHaffTree,n,myHaffCode);
	 

	    	for(i=0; i<n; i++)
	    	{
	        	for(j = myHaffCode[i].start; j<n; j++)
                	count++;
            	count++;
	    	} 
	    	send(fd,&count,sizeof(int),0);//返回其编码后的长度  

	    	for(i=0; i<n; i++)//一个字符一个字符发送
	    	{
	        	for(j = myHaffCode[i].start; j<n; j++)
            	{
	    	    	send(fd,&(myHaffCode[i].bit[j]),sizeof(int),0);       
            	}
            	cht=2;
            	send(fd,&cht,sizeof(int),0);
	    	}  
    	}

    	else if(choice == 2)//如果为译码
    	{
        	recv(fd,demessage,sizeof(demessage),0);//得到要译码的信息

        	haffyima(myHaffTree,n,demessage,weight,message);//进行译码    

        	send(fd,message,sizeof(message),0);//把译码信息返回
   	 	}
   	 	else{
   	 		break;
   	 	}	
   	}
    close(fd);//关闭socket
}
//等待客户端的连接，启动服务器的服务






void service()
{
    printf("服务器开始服务\n");
    while(1)//一直循环，等待客户端链接
    {
        struct sockaddr_in fromaddr;
        socklen_t len = sizeof(fromaddr);
        int fd = accept(sockfd,(SA*)&fromaddr,&len);
        if(fd == -1)
        {
            printf("客户端链接出错\n");
            continue;//继续循环，处理连接
        }
        //如果客户端成功连接上
        pthread_t pid;
        pthread_create(&pid,0,service_thread,&fd);
    }
}

void signal_close(int signal_num){
//关闭服务器前 关闭服务器的socket
    close(sockfd);
    printf("服务器已经关闭\n");
    exit(1);
}

int main()
{
    signal(SIGINT,signal_close);//退出CTRL+C
    init();//初始化服务器
    service();//服务器开始运行
    return 0;
}










chudongfang2015
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈夫曼编码译码器 数据结构与算法 课程设计
06-16
设计一个利用哈夫曼算法的编码和译码系统，重复地显示并处理“要求”中项目，直到选择退出为止。 要求： （1）将权值数据存放在数据文件(文件名为data.txt，位于执行程序的当前目录中) （2）分别采用动态和静态存储结构 （3）从键盘输入字符集大小n、n个字符和n个权值，建立哈夫曼树； （4）利用建好的哈夫曼树生成哈夫曼编码； （5）输出编码； 用户可以执行的的功能有： (1)---选择读取某个源文件由系统解析建立哈夫曼树 (2)---手动输入字符集及其权值信息建立哈夫曼树 (3)---打印字符集的哈夫曼编码到屏幕 (4)---选择某个文本文件进行编码 (5)---选择某个代码文件进行译码
Huffman编码的设计与实现
qq_43573663的博客
03-27 4869
（一）设计描述 1.题目描述 设计一个利用哈夫曼算法的编码和译码系统，重复地显示并处理以下项目，直到选择退出为止。 1) 输入一串字符，然后统计其中各个字符的个数,即每个字符的权值。 2) 进行初始化操作,并建立哈夫曼树； 3) 编码：利用建好的哈夫曼树生成哈夫曼编码，并输出编码； 4) 译码，即输入每个字符对应的二进制的编码（0或1），然后输出对应的字符。 5) 结束操作。 2.设计目的......
Huffman编译器和译码器设计(一)
T_T1528的博客
12-02 512
1. 需求分析 设计一个哈夫曼算法的编码和译码系统，重复地显示并处理以下项目，知道选择退出为止。 将权值数据存放在数据文件中；分别采用动态和静态存储结构； 1. 读权重数据文件获得权重和字符的对应数组 2. 手动输入字符与对应权重值 3. 通过权重字符对应数组生成哈弗曼树 4. 利用建立好的哈弗曼树生成哈弗曼编码 5. 通过建立好的哈弗曼树解析哈弗曼编码生成译码 ...
数据结构课程设计
陆志祥
01-11 2517
数据结构课程设计 一、目的 《数据结构》是一门实践性较强的软件基础课程，为了学好这门课程，必须在掌握理论知识的同时，加强上机实践。本课程设计的目的就是要达到理论与实际应用相结合，使同学们能够根据数据对象的特性，学会数据组织的方法，能把现实世界中的实际问题在计算机内部表示出来，并培养基本的、良好的程序设计技能。 二、要求 通过这次设计，要求在数据结构析逻辑特性和物理表示，数据结构的选择的应用
哈夫曼编解码器.zip
04-24
数据结构与算法课程设计，将需要传送的字母字符等转换为二进制的字符串，用0,1码的不同排列来表示；将输入的字母，字符等转变为哈夫曼树进而构造哈夫曼编码。还有对哈夫曼编码的破译。
哈夫曼编译码系统的简单设计与实现
最新发布
10-31
在"哈夫曼编译码系统的简单设计与实现"这个主题中，我们可能还会涉及如何用编程语言（如Python、C++等）实现哈夫曼编码和解码的过程，包括数据结构的设计、算法的优化以及压缩和解压缩的效率分析。此外，哈夫曼编码...
基于C++实现哈夫曼编译码系统【100012657】
06-07
利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据...试为这样的信息收发站设计一个哈夫曼编译码系统。
哈夫曼编译码器课程设计报告(完整版)--30页.pdf
09-05
哈夫曼编译码器课程设计报告 本报告是一个关于哈夫曼编译码器的课程设计报告，涵盖了哈夫曼编译码器的基本概念、设计要求、算法设计、流程图、源代码等方面的内容。 哈夫曼编译码器是一种高效的数据压缩算法，广泛...
数据结构C 语言哈夫曼编译码基本实现 haffman.c 完整代码
11-10
数据结构C 语言哈夫曼编译码基本实现
HF.zip_哈夫曼编译码器_数据结构
09-21
通过阅读和分析代码，你可以了解如何使用C++的数据结构（如`std::vector`、`std::priority_queue`）和算法（如优先队列、深度优先搜索）来构建和使用哈夫曼编译码器。同时，这也是一个很好的实践机会，加深对数据...
哈夫曼编码-译码器课程设计报告.docx
06-12
设计一个利用哈夫曼算法的编码和译码系统，重复地显示并处理以下项目，直到选择退出为止。 基本要求： （1）将权值数据存放在数据文件(文件名为data.txt，位于执行程序的当前目录中) （2）分别采用动态和静态存储结构 ......
将一段文字转化为哈夫曼编码JAVA实现
02-27
可以通过读取TXT文档，将文档中的文字转换为哈夫曼编码。 若要看代码，请用解压缩软件打开。
java 哈夫曼编码实现翻译
06-13
利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时，降低传输成本。但是，这要求在发送端通过一个编码系统对待传送电文须预先编码，在接收须将传送来的数据进行译码。请自行设计实现一个具有初始化、编码、译码、输入/输出等功能的哈夫曼码的编码/译码系统。并实现以下报文的编码和译码：“this program is my favorite”。
哈夫曼编码与解码的程序
05-07
c语言编写的哈夫曼编码与解码小程序，学生作业
哈夫曼压缩源码及两个样例
12-09
资源中有完整的哈夫曼压缩&解压的算法java实现，并且包括两个运行实例。
哈夫曼编码压缩程序（Java）
12-18
用面向对象的程序设计思想自己动手写压缩软件，采用了优先队列这一很好的数据结构实现的贪心算法构造Huffman树，能打印Huffman树，显示编码表，压缩文件和解压缩文件，采用UTF-8字符集，支持中文文件
java实现huffman编码解码
07-09
本程序利用Java实现以下功能： 1、读取一行或多行数据，统计出现的所有字母的出现次数 2、构造huffman树 3、生成出现字母的编码表 4、对输入的数据进行编码输出 5、输入编码结果，对编码结果进行解码，得到原来的输入数据。
java实现赫夫曼树编码和解码byte[]
12-21
首先对于赫夫曼编码有个大概的理解：赫夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）。 赫夫曼编码，主要目的是根据使用频率来最大化节省字符（编码）的存储空间。(举例来说，对于一个字符串中”i like java do you like a java”中有多个重复字符，我们可以存储一次一个字符对应的编码即可，可以节省存储空间) ；网上大多数用的是char来进行字符个数
matlab实现哈夫曼编译码
05-27
下面是 MATLAB 实现哈夫曼编译码的示例代码： ```matlab % 定义待编码的字符串 str = 'abbcccddddeeeee'; % 统计字符串中每个字符出现的次数 freq = hist(str, unique(str)); % 构建哈夫曼树并生成编码字典 [~, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值