链表哈夫曼树源码

最新推荐文章于 2024-11-02 22:50:17 发布
最新推荐文章于 2024-11-02 22:50:17 发布
阅读量226 收藏
点赞数 1
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2202_75350870/article/details/131277483
版权

hufuman.cpp

main.cpp

otherfunction,cpp

#include"OtherFuntion.h"
#include"HuffmanTree.h"

void MoveCursor( int & x,int & y,int row )
{
	char ch;
	int X = x, Y = y;
	HideCursor();
	gotoxy( x,y );
	printf("→");
	while( 1 )
	{
		ch = getch();
		switch( ch )
		{
		case 'S':
		case 's':  {
						gotoxy(x,y);
						printf("  ");
						y = y + 2;
						if( y > ( 2*(row-1) ) + Y )
							y = y - 2*row;
						gotoxy( x,y );
						printf("→");
						break;
				   } 
		case 'W':
		case 'w':  {
						gotoxy(x,y);
						printf("  ");
						y = y - 2;
						if( y < Y )
							y = Y + 2*(row-1);
						gotoxy( x,y );
						printf("→");
						break;
				   }
		case '\r': {
						return;
				   }
		}
	}
}

void HMoveCursor( int & x,int & y )
{
	char ch;
	HideCursor();
	gotoxy( x,y );
	printf("→");
	while( 1 )
	{
		ch = getch();
		switch( ch )
		{
		case 'A':
		case 'a':  {
						gotoxy(x,y);
						printf("  ");
						x = x-11;
						if( x < 12 )
							x = 23;
						gotoxy( x,y );
						printf("→");
						break;
				   } 
		case 'D':
		case 'd':  {
						gotoxy(x,y);
						printf("  ");
						x = x+11;
						if( x > 23 )
							x = 12;
						gotoxy( x,y );
						printf("→");
						break;
				   }
		case '\r': {
						return;
				   }
		}
	}
}

void Menu( HuffmanTree & HT,HuffmanCode & HC,char EnteringData[] )
{
	int x = 15,y = 8;
	gotoxy(2,2);
	printf("\n\t控制 W,S 键移动光标,按Enter进入。【www.itstudy8.net】站长原创\n");
	HideCursor();
	DrawTable( 17,16,12,5 );
	gotoxy(17,8 );
	printf("1.初始化哈夫曼树");
	gotoxy(17,10 );
	printf("2.编码");
	gotoxy(17,12 );
	printf("3.译码");
	gotoxy(17,14 );
	printf("4.打印哈夫曼编码");
	gotoxy(17,16 );
	printf("5.打印哈夫曼树");
	gotoxy(17,18 );
	printf("6.退出系统");
	MoveCursor( x,y,6 );
	
	switch( y )
	{
	case 8:   InitHuffman( HT,HC,EnteringData );          break;
	case 10:  Encoding( HT,HC,EnteringData );             break;
	case 12:  Decoding( HT,HC );                          break;
	case 14:  PrintHuffmanCode( HC );                     break;
	case 16:  PrintHuffmanTree( HT,HC );                  break;
	case 18:  gotoxy(0,23);                               exit( 1 ); 
	}
}

void InitHuffman( HuffmanTree & HT,HuffmanCode & HC,char EnteringData[] )
{
	int x = 15,y = 2;
	system("cls");
	DrawTable( 7,16,12,1 );
	gotoxy(17,2 );
	printf("1.键盘");
	gotoxy(17,4 );
	printf("2.文档");
	gotoxy(17,6 );
	printf("3.返回主菜单");
	MoveCursor( x,y,3 );

	switch( y )
	{
	case 2:  KeyBoard( HT,HC,EnteringData );     break;
	case 4:  Document( HT,HC,EnteringData );     break;
	case 6:  system("cls");                      return; 
	}
}

void KeyBoard( HuffmanTree & HT,HuffmanCode & HC,char EnteringData[] )
{
	gotoxy(0,8);
	HideCursor1();
	printf("输入文本内容(以#结束)：\n");
	printf("=====================================================\n");

	int i = 0;
	char ch = getchar(),flag;
	while( ch != '#' )
	{
		EnteringData[i] = ch;
		++i;
		ch = getchar();
	}
	EnteringData[i] = '\0';
	CountFrequency( HC,EnteringData );   //统计频率

	printf("\n是否要保存文本? Y/N? : ");
	getchar();
	flag = getchar();
	if( flag == 'Y' || flag == 'y' )
	{
		FILE *fp = fopen("document.txt","wb");
		if( ! fp )
		{
			MessageBox(NULL,"文件打开失败!","提示",MB_OK);
			system("cls");
			return;
		}
		i = 0;
		while( EnteringData[i] != '\0' )
		{
			ch = EnteringData[i];
			fputc( ch,fp );
			++i;
		}
		fclose( fp );
	}

	printf("\n是否显示文本? Y/N? ：");
	getchar();
	flag = getchar();
	if( flag == 'Y' || flag == 'y' )
	{
		ShowDocument( EnteringData );
	}
	else
	{
		system("cls");
		return;
	}
}

void Document( HuffmanTree & HT,HuffmanCode & HC,char EnteringData[] )
{
	char path[30];
	int i = 0;

	gotoxy(0,9);
	HideCursor1();
	printf("请输入文档路径(如 C:\\english.txt) : ");
	gets( path );
	FILE *fp = fopen(path,"rb");
	if( ! fp )
	{
		MessageBox(NULL,"文件打开失败!","提示",MB_OK);
		system("cls");
		return;
	}
	while( ! feof( fp ) )
	{
		EnteringData[i] = fgetc( fp );
		++i;
	}
	EnteringData[i] = '\0';
	fclose( fp );

	ShowDocument( EnteringData );
	CountFrequency( HC,EnteringData );
}

void ShowDocument( char EnteringData[] )
{
	system("cls");
	gotoxy(7,0);
	printf("文本内容");
	DrawTable(23,20,0,1);
	DrawTable(23,20,20,1);
	gotoxy(1,2);

	int x = 1,y = 24;
	int i = 0,row = 2,flag = 0;
	while( EnteringData[i] != '\0' )
	{
		if( EnteringData[i] == '\n' )
		{
			row = row + 2;
			gotoxy(x,row);
			flag = 0;
			++i;
		}
		printf("%c",EnteringData[i]);
		++flag;
		if( flag == 36 )
		{
			row = row + 2;
			gotoxy(x,row);
			flag = 0;
		}
		++i;
		if( x == 21 && row > 20 )
		{
			printf("......");
			break;
		}
		if( row > 20 )
		{
			x = 21;
			row = 0;
			flag = 0;
		}
	}

	x = 12,y = 24;
	gotoxy(13,24);
	printf("1.返回\t\t2.退出");
	HMoveCursor(x,y);

	switch( x )
	{
	case 12:  system("cls");   return;
	case 23:  gotoxy(0,25);    exit( 1 );
	}
}

void CountFrequency( HuffmanCode & HC,char EnteringData[] )
{
	int i = 0;
	for( i = 0; i < MAX_CHAR_SIZE; ++i )
	{
		HC[i].ch = i;
		HC[i].frequency = 0;
		HC[i].code = NULL;
	}
	for( i = 0; EnteringData[i] != '\0'; ++i )
	{
		int Ascii = EnteringData[i];
		HC[Ascii].frequency++;
	}

	FILE *fp = fopen("HuffmanTree.txt","wb");
	if( ! fp )
	{
		MessageBox(NULL,"HuffmanTree文件打开失败!","提示",MB_ICONERROR | MB_OK);
		system("cls");
		return;
	}
	else
	{
		for( i = 0; i < MAX_CHAR_SIZE; ++i )
		{
			fwrite( &HC[i],sizeof( struct Huffman ),1,fp );
		}
		fclose( fp );
	}
}

void Encoding( HuffmanTree & HT,HuffmanCode & HC,char EnteringData[]  )  //编码
{	
	if( HC[0].ch == NULL )
	{
		char code[MAXCODELEN];
		CreateHuffmanTree( HT,HC );
		HuffmanTree RootNode = HT->next;
		while( RootNode->next != NULL )  //找根结点
		{
			RootNode = RootNode->next;
		}
		PreOrderEncode( RootNode,HC,code,0 );  //先序遍历编码
	}
	else
	{
		MessageBox(NULL,"没有文档录入,请录入文档后编码!","提示",MB_ICONERROR | MB_OK);
		return;
	}
	int ref = MessageBox(NULL,"编码成功,是否要保存哈夫曼编码?","提示",MB_ICONQUESTION | MB_YESNO);
	if( IDYES == ref )
	{
		FILE *fp = fopen("HuffmanCode.txt","wb");
		if( ! fp )
		{
			MessageBox(NULL,"文件打开失败!","提示",MB_ICONERROR | MB_OK);
			system("cls");
			return;
		}
		for( int i = 0; EnteringData[i] != '\0'; ++i )
		{
			int Ascii = EnteringData[i];
			if( Ascii < 0 )   //当出现在不是0～128的Ascii时，不能实现编码，退出循环
				break;
			fputs( HC[Ascii].code,fp );
		}
		fclose( fp );
	}
	else
	{
		system("cls");
		return;
	}
}

void PreOrderEncode( HuffmanTree RootNode,HuffmanCode & HC,char code[],int n ) //先序遍历编码，用递归实现
{
	if( RootNode->lchild == NULL && RootNode->rchild == NULL )
	{
		int Ascii = RootNode->ch;
		HC[Ascii].code = ( char * )malloc( (n+1) * sizeof( char ) );
		if( ! HC[Ascii].code )
			exit( OVERFLOW );
		for( int i = 0; i < n; ++i )
		{
			HC[Ascii].code[i] = code[i];
		}
		HC[Ascii].code[i] = '\0';
		return;
	}
	if( RootNode->lchild )
	{
		code[n] = '0';
		PreOrderEncode( RootNode->lchild,HC,code,n+1 );
	}
	if( RootNode->rchild )
	{
		code[n] = '1';
		PreOrderEncode( RootNode->rchild,HC,code,n+1 );
	}
}

void CreateHuffmanTree( HuffmanTree & HT,HuffmanCode & HC )
{
	int len;
	HT = ( HuffmanTree )malloc( sizeof( HTNode ) );
	HT->next = NULL;
	HT->weigth = 0;
	HT->lchild = NULL;
	HT->rchild = NULL;
	HT->parent = NULL;
	HT->ch = NULL;

	HuffmanTree Head = HT,Next,New;
	for( int i = 0; i < MAX_CHAR_SIZE; ++i )
	{
		if( HC[i].frequency != 0 )
		{
			Next = ( HuffmanTree )malloc( sizeof( HTNode ) );
			if( ! Next )
				exit( OVERFLOW );
			Next->weigth = HC[i].frequency;
			Next->lchild = NULL;
			Next->rchild = NULL;
			Next->parent = NULL;
			Next->next = NULL;
			Next->ch = HC[i].ch;
			Head->next = Next;
			Head = Next;
		}
	}
	HuffmanNodeSort( HT,len );  //对链表进行排序

	HuffmanTree FirstFind,SecondFind;
	FirstFind = HT->next;
	SecondFind = FirstFind->next;
	for( i = 0; i < len-1; ++i )
	{
		New = ( HuffmanTree )malloc( sizeof( HTNode ) );
		if( ! New )
			exit( OVERFLOW );
		FirstFind->parent = New;
		SecondFind->parent = New;
		New->weigth = FirstFind->weigth + SecondFind->weigth;
		New->lchild = FirstFind;
		New->rchild = SecondFind;
		New->parent = NULL;
		New->next   = NULL;
		New->ch = NULL;
		InsertNode( SecondFind,FirstFind,New );  //插入新结点
	}
}

void HuffmanNodeSort( HuffmanTree & HT,int & Len )  //排序函数
{
	int len = 0;
	HuffmanTree Head = HT->next,Prior,Next;
	while( Head != NULL )
	{
		++len;
		Head = Head->next;
	}
	Len = len;

	bool exchange = TRUE;
	while( exchange )   //对链表进行排序, 采用优化后的冒泡排序算法
	{
		exchange = FALSE;
		Prior = HT;
		Head = HT->next;
		Next = Head->next;
		for( int i = 0; i < len-1; ++i )
		{
			if( Head->weigth > Next->weigth )
			{
				Prior->next = Next;
				Head->next = Next->next;
				Next->next = Head;
				Prior = Next;
				Next = Head->next;
				exchange = TRUE;
			}
			else
			{
				Prior = Prior->next;
				Head = Head->next;
				Next = Head->next;
			}
		}
		len--;
	}
}

void InsertNode( HuffmanTree & SecondFind,HuffmanTree & FirstFind,HuffmanTree &New )
{
	HuffmanTree Prior,Next;
	Prior = SecondFind;
	Next  = SecondFind->next;
	if( SecondFind->next == NULL )  //SecondFind 指向链表结尾的情况，并将新结点插入链表
	{
		SecondFind->next = New;
		return;
	}
	while( New->weigth > Next->weigth && Next->next != NULL )  //SecondFind 没有指向链尾，进行有序插入
	{
		Prior = Prior->next;
		Next  = Next->next;
	}
	if( Next->next == NULL )   //实现链表的插入
	{
		Next->next = New;
	}
	else
	{
		New->next = Next;
		Prior->next = New;
	}
	FirstFind = SecondFind->next;   //First Second 分别指向下两个结点
	SecondFind = FirstFind->next;
}

void Decoding( HuffmanTree & HT,HuffmanCode & HC )
{
	int i = 0;
	char EnteringData[MAX_FILE_SIZE];
	HT = ( HuffmanTree )malloc( sizeof( HTNode ) );
	HT->next = NULL;
	HT->weigth = 0;
	HT->lchild = NULL;
	HT->rchild = NULL;
	HT->parent = NULL;
	HT->ch = NULL;
	
	FILE *fp = fopen("HuffmanTree.txt","rb");
	if( ! fp )
	{
		MessageBox(NULL,"文件打开失败!","提示",MB_OK);
		system("cls");
		return;
	}
	else
	{
		for( int i = 0; i < MAX_CHAR_SIZE; ++i )
		{
			fread( &HC[i],sizeof( struct Huffman ),1,fp );
		}
		fclose( fp );
		CreateHuffmanTree( HT,HC );
	}

	fp = fopen("HuffmanCode.txt","rb");
	if( ! fp )
	{
		MessageBox(NULL,"文件打开失败!","错误",MB_ICONERROR | MB_OK);
		system("cls");
		return;
	}
	HuffmanTree RootNode = HT->next,Decode;
	while( RootNode->next != NULL )  //找根结点
	{
		RootNode = RootNode->next;
	}
	Decode = RootNode;

	gotoxy(0,23);
	while( ! feof( fp ) )  //解码，采用非递归算法
	{
		char ch = fgetc( fp );
		if( ch == '0' && Decode->lchild )
		{
			Decode = Decode->lchild;
		}
		if( ch == '1' && Decode->rchild )
		{
			Decode = Decode->rchild;
		}
		if( Decode->lchild == NULL && Decode->rchild == NULL )
		{
			EnteringData[i] = Decode->ch;
			++i;
			printf("%c",Decode->ch);
			Decode = RootNode;
		}
	}
	EnteringData[i] = '\0';
	fclose( fp );
	printf("\n请按任意键继续...\n");
	getch();

	int ref = MessageBox(NULL,"译码成功,是否要保存译码内容?","提示",MB_ICONQUESTION | MB_YESNO);
	if( IDYES == ref )
	{
		fp = fopen("contents.txt","wb");
		if( ! fp )
		{
			MessageBox(NULL,"文件打开失败!","提示",MB_ICONERROR | MB_OK);
			system("cls");
			return;
		}
		i = 0;
		while( EnteringData[i] != '\0' )
		{
			fputc( EnteringData[i],fp );
			++i;
		}
		fclose( fp );
		system("cls");
	}
	else
	{
		system("cls");
		return;
	}
}

void PrintHuffmanCode( HuffmanCode HC )
{
	system("cls");
	printf("\t\t\t\t  字符编码\n");
	printf("================================================================================");
	printf("字符            出现次数               哈夫曼编码                             \n");
	printf("================================================================================");
	if( HC[0].ch == NULL )
	{
		for( int i = 31; i < MAX_CHAR_SIZE; ++i )
		{	
			if( HC[i].frequency == 0 )
				continue;
			if( HC[i].ch == ' ' )
			{
				printf("NULL\t\t%d\t\t\t%s\n",HC[i].frequency,HC[i].code);
				continue;
			}
			printf("%c\t\t%d\t\t\t%s\n",HC[i].ch,HC[i].frequency,HC[i].code);
		}
	}
	else
	{
		MessageBox(NULL,"没有文档录入,请录入文档后编码!","提示",MB_ICONERROR | MB_OK);
		system("cls");
		return;
	}
	printf("\n\n请按任意键继续...");
	getch();
	system("cls");
}

void PrintHuffmanTree( HuffmanTree HT,HuffmanCode HC )
{
	gotoxy(0,23);
	int n;
	printf("1.直接打印树\t2.凹入表打印树\n");
	scanf("%d",&n);

	if( HC[0].ch == NULL )
	{
		HuffmanTree RootNode = HT->next;
		while( RootNode->next != NULL )  //找根结点
		{
			RootNode = RootNode->next;
		}
		if( n == 1 )
		{
			initgraph(1300,600);
			PaintBiTree(RootNode,630,20,300);
			outtextxy(0,500,"请按任意键继续...");
			getch();
			closegraph();
		}
		else if( n == 2 )
		{
			system("cls");
			PreOrderPrintTree(RootNode,1);
			printf("请按任意键继续...\n");
			getch();
		}
		system("cls");
	}
	else
	{
		MessageBox(NULL,"没有构造哈夫曼树，请构造哈夫曼树后打印!","提示",MB_ICONERROR | MB_OK);
		system("cls");
		return;
	}
}

void PaintBiTree(HuffmanTree T,int x,int y,int t)
{ 
	int m,n,x1,y1,x2,y2,x3,y3,x4,y4;
	char str[10];
	char c[2];
	m = (int)sqrt( 100.0*t*t / (1600+t*t) );	//x轴
	n = (int)sqrt( 160000.0  / (1600+t*t) );	//y轴
	x1 = x-m;
	y1 = y+n;
	x2 = x-t+m;
	y2 = y+40-n;
	x3 = x+m;
	y3 = y+n;
	x4 = x+t-m;
	y4 = y+40-n;
	if( T )
	{
		circle(x,y,10);
		if( T->lchild )
			line(x1,y1,x2,y2);
		if( T->rchild )
			line(x3,y3,x4,y4);
		itoa(T->weigth,str,10);
		outtextxy(x-5,y-8,str);
		if( T->ch != NULL )
		{
			if( T->ch == ' ' )
			{
				outtextxy(x-5,y+12," 空格");
			}
			c[0] = T->ch;
			c[1] = '\0';
			outtextxy(x-5,y+12,c);
		}
		PaintBiTree(T->lchild,x-t,y+40,t/2);
		PaintBiTree(T->rchild,x+t,y+40,t/2);
	}
}

void PreOrderPrintTree( HuffmanTree T,int Level )
{
	if( T )
	{
		if( Level == 1 )
		{
			printf("%d\n",T->weigth);
		}
		else if( Level == 2 )
		{
			printf("├─%d\n",T->weigth);
		}
		else
		{
			printf("│");
			int SpaceNum = 2*(Level-2) - 1;
			for( int i = 1; i <= SpaceNum; ++i )
			{
				if( i % 2 == 0 )
					printf("│");
				else
					printf("  ");
			}
			if( T->lchild == NULL && T->rchild == NULL )
			{
				if( T->ch == ' ' )
					printf("└─%d NULL\n",T->weigth);
				else if( T->ch == '\n' )
					printf("└─%d  \\n\n",T->weigth);
				else
					printf("└─%d  %c\n",T->weigth,T->ch);
			}
			else
			{
				printf("├─%d\n",T->weigth);
			}
		}

		if( T->lchild )
			PreOrderPrintTree(T->lchild,Level+1);
		if( T->rchild )
			PreOrderPrintTree(T->rchild,Level+1);
	}
}

 

 

 

疯狂的大只因
关注
C++链表：哈夫曼树（附源码）
C语言C++学习俱乐部：765860056
10-18 1459
在开始之前先给大家介绍一下什么是哈夫曼树 哈夫曼树就是给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。 1、路径和路径长度 在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。 2、结点的权及带权路径长度 若将树中结点赋给一个有着某种含义的数值，则这...
哈夫曼树及哈夫曼树编码译码详解
m0_73555097的博客
04-27 1912
使用链表形式，实现哈夫曼树的构建及编码译码
哈夫曼树与哈夫曼编码
whiteBearClimb的博客
11-19 5227
例如：根结点代表着快递集散点，一个叶子结点权值是5，在业务逻辑中代表着重量是5斤的货物📦，路径长度是3，业务逻辑代表着3公里，3 * 5 = 15 假设代表着从根结点开始配送这一件货物的成本 开销是15升汽油越重的物品，配送距离越长，开销越大，假设说每一层结点都有一个快递柜，只可以存放一件物品，这样就让收件人自己来取，而不用大老远送过去了，那么我们就应该优先把最重的物品，放在距离快递集散点（根结点）越近的位置。重量轻的（权值小的）小件物品我们可以送远一点。 那么这个想法其实就是最短带权路径例：假设快递站今
链表和树的leetcode题
JokeOrSerious的博客
04-21 741
注意保存上下文环境。注意gc，不要有垃圾变量。换头结点注意考虑头对于链表不要在乎是O(n)还是O(2n)长短链表互换。
基于哈夫曼树的数据压缩算法（C语言）
Cap07博客
12-04 4215
头文件（head.h）： #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef int ElemType; typedef int Status; typedef struct { ElemType* base; ElemType* top; int stacksize; }SqStack, * SqStacklist; SqStacklist InitStack(); void Push(SqStacklist S, El
数据结构“二叉树操作的实现”与“基于哈夫曼树的数据压缩算法”的实验报告
weixin_62075168的博客
11-22 2288
利用二叉树的二叉链表的存储结构，编写一个程序完成对二叉树的操作的实现。
树，二叉树，哈夫曼树...
个人站点：javatv.net
07-15 1266
写在前面 之前讲的链表，栈，队列等都是线性存储结构，都是一对一的关系。而树是具有一对多关系的数据结构。比如我们经常说的湖北省武汉市，湖南长沙的一个类图，就类似于一颗倒转的树。 什么是树 树是一种数据结构，由n个节点构成的具有层次关系的有限集合。 树的基本术语 节点：树中的每一个数据元素都是节点（A，B…） 节点的度：节点的子树个数（A的子树为B和C） 树的度：树中所有节点最大的度（树A和树C的度都是2） 叶子节点：度为0的节点（D，E，F） 节点的层次：树的根开始，树根所在的层为第一层，根的子节点所在的
实例图解哈夫曼树编码-解码及实现（c++）
热门推荐
努力做个书呆儿
01-15 1万+
hello everybody!你们机智大气的阿俊又回来了，最近事比较多，闲话少说，直接切入正题，聊聊如何给一篇全为英文字符的文章利用哈夫曼编码得到每个字符的最优编码，并完成解码功能，注意，这次也是用文件操作哟，今天可被二进制文件折磨惨了，不过搞懂后真好用，呜呜呜，我该不会是个受虐狂叭。。。 需求分析 嘿嘿嘿，不瞒你说，这是我课设的题目 注意一下，测试数据一定是所有的字符一定是要英文输入法能...
【数据结构与算法基础】哈夫曼树与哈夫曼编码(C++)
wayne_lee_lwc的博客
11-23 5775
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
链表HuffmanTree源码.zip
06-17
链表HuffmanTree源码.zip这个压缩包文件包含了一个关于哈夫曼树（Huffman Tree）的实现，它是数据结构和算法领域中的一个重要概念。哈夫曼树是一种特殊的二叉树，常用于数据编码，特别是在数据压缩中。下面将详细...
双向链表，二叉树，哈弗曼树的构建
04-22
本话题涵盖了三种重要的数据结构：双向链表、二叉树以及哈弗曼树。这些数据结构在算法设计、数据库系统、编译器和各种软件开发中都有广泛应用。下面我们将深入探讨这三种数据结构的构建方法。 首先，我们来讨论双向...
课设——哈夫曼树的源代码
08-25
3. 最小优先队列实现：可能是使用数组、链表或者优先级队列库来实现，用于存储和合并哈夫曼树节点。 4. 哈夫曼树的构建函数：接受字符频率列表，返回哈夫曼树的根节点。 5. 哈夫曼编码生成函数：遍历哈夫曼树，为每...
通用型函数——冒泡排序
2401_84654619的博客
10-29 313
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
【数据结构篇】探索堆的算法的巧妙
braveact的博客
11-02 507
⽤剩余的N-K个元素依次与堆顶元素来⽐较，不满⾜则替换堆顶元素 ，然后再将交换进去后的元素向下调整（保证这k个元素始终是堆），最后将剩余N-k个元素依次与堆顶元素⽐完之后，堆中剩余的K个元素就是所求的前k个最⼩或者最⼤的元素。对于Top-K问题，能想到的最简单直接的⽅式就是排序，但是：如果数据量⾮常⼤，排序就不太可取了 (可能数据都不能⼀下⼦全部加载到内存中)。依次将堆顶最大的数据与最后一个（不断发生变化）元素交换，每次都是将最大的数据放最后，可以想象一下，就是升序了。前k个最⼩的元素，则建⼤堆。
数据结构，问题 F: 括弧匹配检验
nick_912912的博客
11-02 102
假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。匹配就输出 “OK” ，不匹配就输出“Wrong”。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入仅一行字符（字符个数小于255）输入一个字符串：［（［］［］）］，输出：OK。
20240818 字节跳动 笔试
lc_guo的博客
10-22 3822
BSP驱动开发工程师-OS、4 道编程题
C语言_数据结构_顺序表
最新发布
m0_74445256的博客
11-02 174
本章重点在于对顺序表的增删查改操作~
python数据类型-8-数据结构-Queue (队列)
Lookontime的博客
10-30 248
在python数据类型系列文章中已经介绍了 python的各种数据类型，队列（Queue）是一种非常重要的数据结构，但并不是python的数据类型，队列遵循先进先出（FIFO）的原则，即先插入的元素先被移除，主要的用途是为了支持线程安全和高效的队列操作而设计的！
数据结构之链式结构二叉树的实现（进阶版）
2401_85878549的博客
10-30 286
本篇文章主要讲解链式二叉树的层序遍历以及判断是否为一棵完全二叉树二者将会用到之前学过的队列知识，是将队列和二叉树的整合。
C语言实现哈夫曼编码的链表插入技术
在本项目中，使用链表结构来构建哈夫曼树，每个节点代表哈夫曼树中的一个节点，包含字符、频率、左右子树的指针等信息。 本项目中可能包含以下C语言程序源码： 1. 数据结构定义：包括哈夫曼树节点的定义、链表节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值