树与二叉树

已于 2024-01-20 11:37:39 修改
阅读量964 收藏 23
点赞数 21
分类专栏： 算法与数据结构 文章标签： 深度优先 算法
于 2024-01-20 10:40:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu_xinLL/article/details/135712113
版权

树与二叉树

一，计算机中的树形结构

根节点：最顶层的节点就是根结点，它是整棵树的源头
叶子节点：在树下端的节点，就是其子节点个数为0的节点
节点的度：指定节点有几个分叉就说这个节点的度是几（叶子节点的度为零）
树的度：只看根结点，树的度等价于根节点的度
  • 出度：该节点指向多少个节点
  • 入度：多少个节点指向该节点
节点高度：指从这个节点到叶子节点的距离（一共经历了几个节点）
节点深度：指从这个节点到根节点的距离（一共经历了几个节点）
树的高度：指所有节点高度的最大值
树的深度：指所有节点深度的最大值
节点的层：从根节点开始，假设根节点为第1层，根节点的子节点为第2层，依此类推
树的节点代表 【 集合 】 ，树的边代表 【 关系 】
根节点代表全集

二，广度优先遍历与深度优先遍历

1.广度优先遍历（层序遍历）

使用的数据结构：队列
处理过程：依次压入队首元素的子节点，当队首元素再也没有子节点时，弹出队首元素，以此类推。

 2.深度优先遍历

使用的数据结构：栈
处理过程：不断压入栈元素的子节点，当再无子节点可压时，弹出栈顶元素。
压栈弹出的时间戳（判断节点之间的父子关系）
3与3之间包含5，6，8，9，7表示3的子节点是5，6，7，8，9。
#include <cstdio>
#include <cstdlib>
#include <ctime>
typedef struct Node {
        int key;
        Node * lchild, *rchild;
} Node ;
Node * getNewNode( int key ) {
        Node * p = ( Node *)malloc( sizeof ( Node ));
       p->key = key ;
       p->lchild = p->rchild = NULL ;
        return p;
}
Node *insert( Node * root , int key ) {
        if ( root == NULL ) {
               return getNewNode( key );
       }
        if (rand() % 2) root ->lchild = insert( root ->lchild, key );
        else root ->rchild = insert( root ->rchild, key );
        return root ;
}
void clear( Node * root ) {
        if ( root == NULL ) return ;
       clear( root ->lchild);
       clear( root ->rchild);
       free( root );
}
#define MAX_NODE 10
Node *queue[ MAX_NODE + 5];
int head, tail;
//广度优先遍历
void bfs( Node * root ) {
       head = tail = 0;
       queue[tail++] = root ;
        while (head < tail) {
               Node * node = queue[head];
              printf( "\nnode:%d" , node->key);
               if (node->lchild){
                      queue[tail++] = node->lchild;
                      printf( "\t%d->%d(left)\n" , node->key, node->lchild->key);
              }
               if (node->rchild) {
                      queue[tail++] = node->rchild;
                      printf( "\t%d->%d(right)\n" , node->key, node->rchild->key);
              }
              head++;
       }
       cout << endl;
}
int tot = 0;
//深度优先遍历
void dfs( Node * root ) {
        if ( root == NULL ) return ;
        int start, end;
       tot++;
       start = tot;
        if ( root ->lchild) dfs( root ->lchild);
        if ( root ->rchild) dfs( root ->rchild);
       tot++;
       end = tot;
       printf( "%d:[%d ,%d]\n" , root ->key, start, end);
        return ;
}
int main() {
       srand(time(0));
        Node * root = NULL ;
        for ( int i = 0; i < MAX_NODE ; i++) {
              root = insert(root, rand() % 100);
       }
       bfs(root);
       dfs(root);
        return 0;
}

三，二叉树

1.结构：

每个节点度最多为 2
度为0的节点比度为2的节点多1个

2.特殊类型

完全二叉树： 除了最后一层之外的其他每一层都被完全填充，并且所有结点都保持向左对齐
满二叉树：没有度为1的节点
完美二叉树： 除了叶子结点之外的每一个结点都有两个孩子，每一层都被完全填充

3.完全二叉树：

4.二叉树的作用

作用一：理解高级数据结构的基础
作用二： 练习递归技巧的最佳选择

四，二叉树：遍历与线索化

前序遍历：1  245  36
中序遍历：425  1  36
后序遍历：452  63  1
作用：序列化-->传输数据结构
前序遍历+中序遍历  可恢复原本的数据结构
后序遍历+中序遍历  可恢复原本的数据结构
后序遍历+前序遍历  不可恢复原本的数据结构（难以确定左右子树的数量）
作用：让二叉树表现的想链表，不用借助递归程序，让遍历个高效。
例子：
#include <cstdio>
#include <cstdlib>
#include <ctime>
typedef struct Node {
        int key;
        int ltag, rtag; //1:thread,0:edge;
        struct Node *lchild, *rchild;
} Node ;
Node * getNewNode( int key ) {
        Node * p = ( Node *)malloc( sizeof ( Node ));
       p->key = key ;
       p->ltag = p->rtag = 0;
       p->lchild = NULL ;
       p->rchild = NULL ;
        return p;
}
Node * insert( Node * root , int key ) {
        if ( root == NULL ) return getNewNode( key );
        if (rand() % 2) root ->lchild = insert( root ->lchild, key );
        else root ->rchild = insert( root ->rchild, key );
        return root ;
}
//前序遍历
void pre_order( Node * root ) {
        if ( root == NULL ) return ;
       printf( "%d " , root ->key);
        if ( root ->ltag==0)pre_order( root ->lchild);
        if ( root ->rtag==0)pre_order( root ->rchild);
        return ;
}
//中序遍历
void mid_order( Node * root ) {
        if ( root == NULL ) return ;
        if ( root ->ltag==0)mid_order( root ->lchild);
       printf( "%d " , root ->key);
        if ( root ->rtag==0)mid_order( root ->rchild);
        return ;
}
//后序遍历
void post_order( Node * root ) {
        if ( root == NULL ) return ;
        if ( root ->ltag==0)post_order( root ->lchild);
        if ( root ->rtag==0)post_order( root ->rchild);
       printf( "%d " , root ->key);
        return ;
}
void clear( Node * root ) {
        if ( root == NULL ) return ;
        if ( root ->ltag==0)clear( root ->lchild);
        if ( root ->rtag==0)clear( root ->rchild);
       free( root );
        return ;
}
//将根节点线索化--中序遍历
Node * pre_node = NULL ,*mid_order_root= NULL ;
void __build_mid_order_thread( Node * root ) {
        if ( root == NULL ) return ;
        if ( root ->ltag == 0)__build_mid_order_thread( root ->lchild);
        if (mid_order_root == NULL ) mid_order_root = root ;
        if ( root ->lchild == NULL ) {
               root ->lchild = pre_node;
               root ->ltag = 1;
       }
        if (pre_node && pre_node->rchild == NULL ) {
              pre_node->rchild= root ;
              pre_node->rtag = 1; 
       }
       pre_node = root ;
        if ( root ->rtag == 0)__build_mid_order_thread( root ->rchild);
        return ;
}
//封装
void build_mid_order_thread( Node * root ) {
       __build_mid_order_thread( root );
       pre_node->rchild = NULL ;
       pre_node->rtag = 1;
        return ;
}
//寻找后继
Node * getNext( Node * root ) {
        if ( root ->rtag == 1) return root ->rchild;
        root = root ->rchild;
        while ( root ->ltag == 0) root = root ->lchild;
        return root ;
}
int main() {
       srand(time(0));
        Node *root = NULL ;
#define MAX_NODE 10
        for ( int i = 0; i < MAX_NODE ; i++) {
              root = insert(root, rand() % 100);
       }
       pre_node = NULL ;
       mid_order_root= NULL ;
       build_mid_order_thread(root);
       pre_order(root); printf( "\n" );
       mid_order(root); printf( "\n" );
       post_order(root); printf( "\n" );
        //like linklist
        Node * node = mid_order_root;
        while (node) {
              printf( "%d " , node->key);
              node = getNext(node);
       }
       clear(root);
        return 0;
}

五，广义表：

二叉树转广义表
#define KEY (n) (n?n->key:-1)
typedef struct Node {
        int key;
        Node * lchild, * rchild;
} Node ;
//新建子节点
Node * getNewNode( int key ) {
        Node * p = ( Node *)malloc( sizeof ( Node ));
       p->key = key ;
       p->lchild = p->rchild = NULL ;
        return p;
}
//随机插入
Node * insert( Node * root , int key ) {
        if ( root == NULL ) return getNewNode( key );
        if (rand() % 2) root ->lchild = insert( root ->lchild, key );
        else root ->rchild = insert( root ->rchild, key );
        return root ;
}
//生成随机二叉树
Node * getRandomBinaryTree( int n ) {
        Node * root = NULL ;
        for ( int i = 0; i < n ; i++) {
              root = insert(root, rand() % 100);
       }
        return root;
}
//清除二叉树
void clear( Node * root ) {
        if ( root == NULL ) return ;
       clear( root ->lchild);
       clear( root ->rchild);
       free( root );
        return ;
}
//二叉树转广义表
char buff[1000];
int len = 0;
void __serialize( Node * root ) {
        if ( root == NULL ) return ;
        //root
       len+=snprintf(buff + len, 100, "%d" , root ->key);//返回打印的字节数
        if ( root ->lchild == NULL && root ->rchild == NULL ) return ;
       len += snprintf(buff + len ,100 , "(" );
       __serialize( root ->lchild);
        if ( root ->rchild ){
              len += snprintf(buff + len, 100, "," );
              __serialize( root ->rchild);
       }
       len += snprintf(buff + len, 100, ")" );
        return ;
}
void serialize( Node * root ) {
       memset(buff, 0, sizeof (buff));
       len = 0;
       __serialize( root );
        return ;
}
void print( Node * node ) {
       printf( "%d(%d, %d)\n" , KEY ( node ),
               KEY ( node ->lchild), KEY ( node ->rchild));
        return ;
}
void output( Node * root ) {
        if ( root == NULL ) return ;
       print( root );
       output( root ->lchild);
       output( root ->rchild);
        return ;
}
int main() {
       srand(time(0));
#define MAX_NODE 10
        Node *root = getRandomBinaryTree( MAX_NODE );
       serialize(root);
       output(root);
       printf( "Buff[]:%s\n" , buff);
        return 0;
}
广义表转二叉树
Node * deserialize( char * buff , int n ) {
        //设置根节点
        Node * root = NULL , * p = NULL ;
        //设置栈，储存节点
        Node ** s = ( Node **)malloc( sizeof ( Node *) * MAX_NODE );
        int top = -1, flag = 1, scode = 0;
        for ( int i = 0; buff [i]; i++) {
               if ( buff [i] <= '9' && buff [i] >= '0' ) {
                      scode = 1;
              }
               else if ( buff [i] == '(' ) {
                      scode = 2;
              }
               else if ( buff [i] == ',' ) {
                      scode = 3;
              }
               else if ( buff [i] == ')' ) {
                      scode = 4;
              }
               switch (scode) {
               case 1: {
                       int key=0;
                       //读数
                       while ( buff [i] >= '0' && buff [i] <= '9' ) {
                             key = key * 10 + ( buff [i] - '0' );
                             i += 1;
                      }
                       //生成二叉树
                      p = getNewNode(key);
                       if (flag == 0 && top >= 0) {
                             s[top]->rchild = p;
                      }
                       if (flag == 1 && top >= 0) {
                             s[top]->lchild = p;
                      }
                       //避免重复++
                      i -= 1;
                       break ;
              }
               case 2: {
                       //入栈
                      s[++top] = p;
                      flag = 1; //表示为左子树
                       break ;
              }
               case 3: {
                      flag = 0; //表示为右子树
                       break ;
              }
               case 4: {
                       //取根节点
                       if (top == 0) root = s[top];
                       //出栈
                      top -= 1;
                       break ;
              }
              }
       }
       free(s);
        return root;
}

六，哈夫曼编码

定长编码：对于每一个字符的编码长度都一样
变长编码：由于不同字符出现概率不同，每一个字符的编码长度不同。
编码前缀不能包含另一个编码（任何两个字符不能构成结构关系）
H:表示第几层
L:表示第i个字符在二叉树的第几层
代码实现：
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;
typedef struct Node {
    char ch;
    int freq;
    struct Node * lchild, * rchild;
} Node ;
Node * getNewNode( int freq , char ch ) {
    Node * p = ( Node *)malloc( sizeof ( Node ));
    p->ch = ch ;
    p->freq = freq ;
    p->lchild = p->rchild = NULL ;
    return p;
}
//交换min_node与未处理node_arr的末尾位置
void swap_node( Node ** node_arr , int i , int j ) {
    Node * temp = node_arr [ i ];
    node_arr [ i ] = node_arr [ j ];
    node_arr [ j ] = temp;
    return ;
}
//找出node_arr中未处理部分的freq
int find_min_node( Node ** node_arr , int n ) {
    int ind = 0;
    for ( int j = 1; j <= n ; j++) {
        if ( node_arr [ind]->freq > node_arr [j]->freq) ind = j;
    }
    return ind;
}
Node * buildHaffmanTree( Node ** node_arr , int n ) {
    for ( int i = 1; i < n ; i++) {
        // find two node
        int ind1 = find_min_node( node_arr , n - i);
        swap_node( node_arr , ind1, n - i);
        int ind2 = find_min_node( node_arr , n - i - 1);
        swap_node( node_arr , ind2, n - i - 1);
        // merge two node
        int freq = node_arr [ n - i]->freq + node_arr [ n - i - 1]->freq;
        Node * node = getNewNode(freq, 0);
        node->lchild = node_arr [ n - i - 1];
        node->rchild = node_arr [ n - i];
        //合并后的节点占原来的倒数第二个位置
        node_arr [ n - i - 1] = node;
    }
    return node_arr [0];
}
void clear( Node * root ) {
    if ( root == NULL ) return ;
    clear( root ->lchild);
    clear( root ->rchild);
    free( root );
    return ;
}
#define MAX_CHAR_NUM 128
char * char_code[ MAX_CHAR_NUM ] = { 0 };
void extractHaffmanCode( Node * root , char buff [], int k ) {
    buff [ k ] = 0;
    if ( root ->lchild == NULL && root ->rchild == NULL ) {
        //strdup()主要是拷贝字符串s的一个副本，由函数返回值返回，这个副本有自己的内存空间，和s不相干。
        //功能：复制字符串s
        //说明：返回指向被复制的字符串的指针，所需空间由malloc()分配且可以由free()释放。
        char_code[ root ->ch] = strdup( buff );
        return ;
    }
    buff [ k ] = '0' ;
    extractHaffmanCode( root ->lchild, buff , k + 1);
    buff [ k ] = '1' ;
    extractHaffmanCode( root ->rchild, buff , k + 1);
    return ;
}
int main() {
    char s[10];
    int n, freq;
    scanf( "%d" , &n);
    Node ** node_arr = ( Node **)malloc( sizeof ( Node *) * n);
    for ( int i = 0; i < n; i++) {
        scanf( "%s%d" , s, &freq);
        node_arr[i] = getNewNode(freq, s[0]);
    }
    Node * root = buildHaffmanTree(node_arr, n);
    char buff[1000];
    extractHaffmanCode(root, buff, 0);
    for ( int i = 0; i < MAX_CHAR_NUM ; i++) {
        if (char_code[i] == NULL ) continue ;
        printf( "%c : %s\n" , i, char_code[i]);
    }
    clear(root);
    return 0;
}

七，哈夫曼编码实现任意文件的无损压缩与解压

1    哈夫曼编码实现任意文件的压缩

1.1实验要求

      1）利用哈夫曼编码实现任意文件的无损压缩。

      2）利用mian函数的参数实现在终端的无损压缩操作。

1.2代码设计

      1）压缩操作的封装，umap_freq字节频率哈希表，umap_haffman哈夫曼编码表，node_arr节点数组，buildFreqMap构建字节频率哈希表，buildHaffmanTree构建哈夫曼树，extractHaffmanCode提取哈夫曼编码，createCompressFile创建压缩文件。

      2）哈夫曼树节点的设计

ch是字节，freq是字节频率。

      3)节点的新建和哈夫曼树的删除

4）原文件二进制打开后，读入字符，计算频率，构建字节频率的哈希表，并将创建的节点地址存入node_arr中，

      5）寻找node_arr中频率最小的节点，为后面哈夫曼树的构建做准备

6）每次寻找node_arr中频率最小的节点，并将它与node_arr的最后一位交换，再寻找node_arr中频率第二小的节点并与node_arr的倒数第二位交换，然后在倒数第二位存入，两个最小节点的合成节点，一次建立循环，node_arr[0]存入的便是哈夫曼树的根节点。

      7）读取哈夫曼树的信息，向左遍历，buff(哈夫曼编码)加字符0,向右遍历，buff(哈夫曼编码)加字符1，当遍历到哈夫曼树的叶子节点时，读取buff存入umap_haffman中。

      8）创建文件

  1. 为了解压所有类型的文件，要以二进制的打开和写入压缩文件
  2. 读取压缩文件的绝对路径（path），并存入压缩文件中，然后加入标识符#@@&##@

  1. 将哈夫曼码的种类数量以字节的形式写入压缩文件中，然后加入标识符#@@&##@

  1. 将哈夫曼码，按位压入字节中，若满八位的就继续压入新的字节，不满八位的继续左移，直至压满8位，这样既可以减少压缩文件的大小，也可以保证新的字符串类型的哈夫曼码不会出现重复。
  2. 以二进制的形式按字节读取要压缩的原文件，通过umap（保存<字节，新的字符串类型的哈夫曼码>），转换成哈夫曼码以二进制的形式按字节存入压缩文件中。

  1. main函数，利用循环读取文件名，并考虑文件名有空格的情况

1.3实验结果与分析

    /*要压缩的文件较大时，压缩时间可能会比较大*/

1)在终端打开mycompress.exe

      2)压缩操作

        在终端输入./mycompress + 要压缩的文件绝对路径

        ./mycompress表示mycompress.exe

1.4 mycompress.cpp
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
#include<unordered_map>
#include<fstream>
#include<cstdio>
using namespace std;
/**********************************************************************************
注意：
       1.可以压缩解压任意文件！！！
***********************************************************************************/
typedef struct Node {
       char ch;
       int freq;
       struct Node* lchild, * rchild;
       Node(char ch, int freq, Node* l = NULL, Node* r = NULL) :ch(ch), freq(freq), lchild(l), rchild(r) {}
}Node;
Node* getNewNode(char ch, int freq) {
       Node* p = new Node(ch, freq);
       return p;
}
void clear(Node* root) {
       if (root == NULL)return;
       clear(root->lchild);
       clear(root->rchild);
       delete root;
       return;
}
//原文件的freq_table的创建
void buildFreqMap(unordered_map<char, int>& umap_freq, vector<Node*>& node_arr, string& path) {
       ifstream file;
       file.open(path.c_str(), ios::in | ios::binary);
       if (file.is_open()) {
              char ch;
              while (file.read(&ch, sizeof(ch))) {
                      umap_freq[ch] += 1;
              }
              cout << "打开成功" << endl;
              file.close();
       }
       else {
              cout << "打开失败" << endl;
       }
       for (auto& x : umap_freq) {
              node_arr.push_back(getNewNode(x.first, x.second));
       }
       return;
}
//寻找vector中frequency最小的node
int find_min_node(vector<Node*>& node_arr, int n) {
       int ind = 0;
       for (int i = 1; i <= n; i++) {
              if (node_arr[ind]->freq > node_arr[i]->freq) ind = i;
       }
       return ind;
}
//建Huffman树
Node* buildHaffmanTree(vector<Node*>& node_arr) {
       for (int i = 1, I = node_arr.size(); i < I; i++) {
              int ind1 = find_min_node(node_arr, I - i);
              swap(node_arr[ind1], node_arr[I - i]);
              int ind2 = find_min_node(node_arr, I - i - 1);
              swap(node_arr[ind2], node_arr[I - i - 1]);
              int freq = node_arr[I - i]->freq + node_arr[I - i - 1]->freq;
              Node* node = getNewNode(0, freq);
              node->lchild = node_arr[I - i - 1];
              node->rchild = node_arr[I - i];
              node_arr[I - i - 1] = node;
       }
       return node_arr[0];
}
//创建HuffmanTable
void extractHaffmanCode(Node* root, unordered_map<char, string>& umap_haffman, string buff) {
       if (root->lchild == NULL && root->rchild == NULL) {
              umap_haffman[root->ch] = buff;
              return;
       }
       buff.push_back('0');
       extractHaffmanCode(root->lchild, umap_haffman, buff);
       buff[buff.size() - 1] = '1';
       extractHaffmanCode(root->rchild, umap_haffman, buff);
       return;
}
void menu() {
       printf("******************************************************\n\n");
       printf("1.压缩文件\n");
       printf("2.解压文件\n");
       printf("3.退出\n\n");
       printf("******************************************************\n\n");
       return;
}
//创建压缩文件
void createCompressFile(string& path, unordered_map<char, string>& umap_haffman) {
       string name;
       printf("新建压缩文件的名称:> default_compressFile.haf\n");
       name = "default_compressFile.haf";
       printf("压缩中....\n");
       ofstream compressFile;
       compressFile.open(name.c_str(), ios::out | ios::binary);
       vector<char> filetype;
       for (int i = path.size() - 1; i >= 0; i--) {
              if (path[i] == '.')break;
              filetype.insert(filetype.begin(), path[i]);
       }
       for (int i = 0; i < filetype.size(); i++) {
              compressFile.write(&filetype[i], sizeof(filetype[i]));
       }
       char end1 = '#';
       char end2 = '@';
       char end3 = '&';
       compressFile.write(&end1, sizeof(end1));
       compressFile.write(&end2, sizeof(end2));
       compressFile.write(&end2, sizeof(end2));
       compressFile.write(&end3, sizeof(end3));
       compressFile.write(&end1, sizeof(end1));
       compressFile.write(&end1, sizeof(end1));
       compressFile.write(&end2, sizeof(end2));
       unordered_map<char, vector<char>> umap;
       if (compressFile.is_open()) {
              int len = umap_haffman.size();
              char ch = 0;
              int cnt = 0;
              while (len) {
                      if (len > 100) {
                             ch = 100;
                             compressFile.write(&ch, sizeof(ch));
                             len -= 100;
                      }
                      else if (len == 100) {
                             ch = 100;
                             compressFile.write(&ch, sizeof(ch));
                             len = 0;
                      }
                      else if (len < 100) {
                             ch = len;
                             compressFile.write(&ch, sizeof(ch));
                             len = 0;
                      }
              }
              compressFile.write(&end1, sizeof(end1));
              compressFile.write(&end2, sizeof(end2));
              compressFile.write(&end2, sizeof(end2));
              compressFile.write(&end3, sizeof(end3));
              compressFile.write(&end1, sizeof(end1));
              compressFile.write(&end1, sizeof(end1));
              compressFile.write(&end2, sizeof(end2));
              ch = 0;
              cnt = 0;
              for (auto x : umap_haffman) {
                      compressFile.write(&x.first, sizeof(x.first));
                      int size = x.second.size();
                      char num = x.second.size() / 8 + (x.second.size() % 8 == 0 ? 0 : 1);
                      compressFile.write(&num, sizeof(num));
                      for (int i = 0; i <= size - 1; i++) {
                             if (x.second[i] == '1') {
                                    ch |= 1;
                                    cnt += 1;
                             }
                             else {
                                    ch |= 0;
                                    cnt += 1;
                             }
                             if (cnt < 8 && i != size - 1) {
                                    ch <<= 1;
                             }
                             else {
                                    cnt = 0;
                                    if (i == size - 1 && size % 8 != 0) {
                                           ch <<= 8 - size % 8;
                                    }
                                    umap[x.first].push_back(ch);
                                    compressFile.write(&ch, sizeof(ch));
                                    ch = 0;
                             }
                      }
              }
              ifstream file;
              file.open(path.c_str(), ios::in | ios::binary);
              if (file.is_open()) {
                      char buff;
                      while (file.read(&buff, sizeof(buff))) {
                             for (int i = 0; i < umap[buff].size(); i++) {
                                    compressFile.write(&umap[buff][i], sizeof(umap[buff][i]));
                             }
                      }
                      cout << "读出成功！\n" << endl;
                      file.close();
              }
              else {
                      cout << "读出失败！\n" << endl;
              }
              compressFile.close();
              cout << "写入成功！\n" << endl;
       }
       else {
              cout << "打开文件失败！\n" << endl;
       }
}
//压缩
void compressFile(string path) {
       unordered_map<char, int> umap_freq;
       unordered_map<char, string> umap_haffman;
       vector<Node*> node_arr;
       buildFreqMap(umap_freq, node_arr, path);
       Node* root = buildHaffmanTree(node_arr);
       string buff;
       extractHaffmanCode(root, umap_haffman, buff);
       createCompressFile(path, umap_haffman);
       clear(root);
}
int main(int argc, char* argv[]) {
       if(*(argv + 1) != NULL){
              int cnt = 1;
              string path;
              while (argv[cnt] != NULL) {
                      if (cnt != 1)path += " ";
                      path += string(argv[cnt++]);
              }
              compressFile(path);
       }
    else cout << "压缩失败--没有有效输入" << endl;
       return 0;
}

2 哈夫曼编码实现任意文件的解压

2.1实验要求

      1）利用哈夫曼编码实现任意文件的无损解压。

      2）利用mian函数的参数实现在终端的无损解压操作。

2.2代码设计

1）封装解压步骤，umap_haffman是哈夫曼码和对应的字节的哈希表

2）以二进制的形式打开压缩文件，读取原文件的文件名后缀（文件类型），通过标识符（#@@&##@），找到文件名后缀，存入filetype

3）先读取哈夫曼码的种类数量（SIZE），再根据SIZE读取压缩文件的哈夫曼码和与它对应的二进制字节，存入umap_haffman(<哈夫曼码，二进制字节>)。

4）读取压缩文件中的哈夫曼码集，转换为相应的字节，以二进制的形式写入解压文件

2.3实验结构与分析

1）解压png

  1. ./myuncompress表示myuncompress.exe
  2. 在终端输入./myuncompress+ 要解压的文件绝对路径
2.4 myuncompress.cpp
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
#include<unordered_map>
#include<fstream>
#include<cstdio>
using namespace std;
/**********************************************************************************
注意：
       1.可以压缩解压任意文件！！！
***********************************************************************************/
//创建解压文件的haffman_table
void completeDecomopress(string path, unordered_map<string, char>& umap_haffman) {
       ifstream compressFile;
       compressFile.open(path.c_str(), ios::in | ios::binary);
       string end = "#@@&##@";
       string temp;
       while (temp.find(end) == -1) {
              char ch;
              compressFile.read(&ch, sizeof(ch));
              temp.push_back(ch);
       }
       string filetype(temp.begin(), temp.begin() + (temp.size() - 7));
       string len;
       while (len.find(end) == -1) {
              char ch;
              compressFile.read(&ch, sizeof(ch));
              len.push_back(ch);
       }
       string num;
       int SIZE = 0;
       for (int i = 0; i < len.size() - 7; i++) {
              SIZE += (int)len[i];
       }
       for (int i = 0; i < SIZE; i++) {
              char ch, size;
              compressFile.read(&ch, sizeof(ch));
              compressFile.read(&size, sizeof(size));
              string s;
              for (int i = 0; i < (int)size; i++) {
                      char c;
                      compressFile.read(&c, sizeof(c));
                      s.push_back(c);
              }
              umap_haffman[s] = ch;
       }
       string name;
       printf("新建解压文件的名称:>default_decompressFile.%s\n", filetype.c_str());
       name = "default_decompressFile." + filetype;
       printf("解压中.....\n");
       ofstream decompressFile;
       decompressFile.open(name.c_str(), ios::out | ios::binary);
       if (decompressFile.is_open()) {
              char ch;
              string s;
              while (compressFile.read(&ch, sizeof(ch))) {
                      s.push_back(ch);
                      char target;
                      if (umap_haffman.find(s) != umap_haffman.end()) {
                             target = umap_haffman[s];
                             s.clear();
                             decompressFile.write(&target, sizeof(target));
                      }
              }
              decompressFile.close();
              compressFile.close();
              cout << "写入成功！\n" << endl;
       }
       else {
              cout << "打开文件失败！\n" << endl;
       }
}
//解压
void decompressFile(string path) {
       unordered_map<string, char> umap_haffman;
       completeDecomopress(path, umap_haffman);
}
int main(int argc, char* argv[]) {
       if (*(argv + 1) != NULL) {
              int cnt = 1;
              string absolutePath;
              while(argv[cnt] != NULL) {
                      if (cnt != 1) absolutePath += " ";
                      absolutePath += string(argv[cnt++]);
              }
              decompressFile(absolutePath);
       }
       else cout << "解压失败--没有有效地址" << endl;
}
(╯▔皿▔)╯
关注
  • 21
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树、森林与二叉树的转换
CSDN
12-30 14万+
树、森林与二叉树的转换 1、树转换为二叉树 由于二叉树是有序的，为了避免混淆，对于无序树，我们约定树中的每个结点的孩子结点按从左到右的顺序进行编号。 将树转换成二叉树的步骤是： （1）加线。就是在所有兄弟结点之间加一条连线； （2）抹线。就是对树中的每个结点，只保留他与第一个孩子结点之间的连线，删除它与其它孩子结点之间的连线； （3）旋转。就是以树的根结点为轴心，将整棵树顺时针旋转一定...
树与二叉树的转换与遍历
m0_60264901的博客
10-22 2679
学习前言： 树、森林与二叉树之间有一个自然的对应关系，即任何一棵树或一个森林都可唯一地对应于一棵二叉树，而任何一棵二叉树也能唯一地对应于一个森林或一棵树。 话不多说，就让我们抓紧开始吧~ 今日学习目标： 把“树与二叉树的转换”给我拿下！ 今日学习相关知识点： 学习前需要明白一个原理：树中每个结点至多只有一个最左边的孩子（长子）和一个右邻的兄弟。（简单来说，一个结点的左边是这个结点的儿子，右边的是这个结点的兄弟） 今日学习过程： 树的定义：是由n(n≥1)个有限节点组成一个具有层次关系的集合。 如
B树与二叉树
舒克日记的博客
05-24 1672
1、二叉树的问题分析 二叉树的操作效率较高，但是也存在问题, 请看下面的二叉树 二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如1亿)， 就存在如下问题: 问题1：在构建二叉树时，需要多次进行i/o操作(海量数据存在数据库或文件中)，节点海量，构建二叉树时，速度有影响 问题2：节点海量，也会造成二叉树的高度很大，会降低操作速度. 2、多叉树 在二叉树中，每个节点有数据项，最多有两个子节点。如果允许每个节点可以有更多的数据项和更多的子节点，就是多叉树（multiway
＜ 数据结构 ＞ 树与二叉树
bit_zyx的博客
04-11 5309
目录 1、树的概念及结构 树的概念 树的专有名词 树的表示 树在实际中的运用 2、二叉树的概念及结构 概念 现实中的二叉树 特殊的二叉树 二叉树的性质 二叉树的存储结构 1、树的概念及结构 树的概念 现实中的树： 数据结构中的树： 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集...
树与二叉树的相互转换
yiranblade的博客
11-11 5489
树->二叉树 加线 把相应结点的兄弟结点连线 去线 去掉双亲和非最左边孩子的连线 旋转 二叉树->树 加线-去线 将结点与其左孩子的右孩子及其右子孙连线。然后去掉所有结点与其右孩子的连线。 旋转处理 得到二叉树 #森林->二叉树 先将每棵树转换为二叉树 连接每棵树的根结点 以第一颗树的根作为二叉树的根顺时针旋转 #二叉树->森林 将二叉树的根结点与其右孩子及右子孙的连线全部去掉 对剩下的每一棵孤立的二叉树按照二叉树与树的转换规则转换为树 得
数据结构——树与二叉树
yue152152的博客
04-10 2883
从树到二叉树的概念及结构，文末附上了二叉树顺序结构和链式结构实现的入口
【开卷数据结构 】 树与二叉树
Ceylan__的博客
04-26 3152
在之前的文章里，我们学习的一直是一对一的线性结构，可现实中，还有很多一对多的情况需要处理，所以我们需要研究这样一种一对多的数据结构 ——“树”
数据结构（树与二叉树）
jxttutu的博客
03-12 4444
5.1.1树和二叉树的定义 树：是n(n>=0)个结点的有限集，或为空树(n==0),或为非空树 非空树满足：1.有且仅有一个称之为根的结点 2.除根节点之外的其余结点可分为m(m>0)个互不相交的有限集，其中每个集合本身又是一棵树，并且称为根的子树。（递归定义） 5.1.2树的基本术语： 1.结点：树中的一个独立单元，包含一个数据元素和若干个指向子树的分支 2.根结点：非空树中无前趋的结点 ...
树与二叉树基础知识
Yoin.
11-09 6099
5.2树的逻辑结构 5.1.1树的定义和基本术语 1.树的定义 在树中通常将数据元素称为结点 树是n个结点的有限集合；当n=0时，称为空树。 任意一颗非空树满足以下条件： 有且仅有一个特定的根节点 当n>1时，除根结点之外的其余结点被分成m个互不相交的有限集合，其中每个集合又是一棵树，并成为这个根节点的子树。 2.树的基本术语 某结点所拥有的子树的个数成为该结点的度；数中各结点的最大值称为该树的度 度为0的结点称为叶子结点，也成为终端结点；度不为0的结点称为分支结点，也成为
树与二叉树的学习总结
zhaoyun_zzz的专栏
03-15 8339
文章目录一般树二叉树一般二叉树满二叉树完全二叉树二叉排序树二叉树的遍历红黑树B树B+树 经过Python的学习，顺便系统的学习了与树相关的数据结构与算法，因此就记录一下吧，留待以后回忆参考。 一般树 二叉树 一般二叉树 满二叉树 完全二叉树 二叉排序树 二叉树的遍历 红黑树 B树 B+树 ...
树与二叉树详细整理.ppt
01-11
"树与二叉树详细整理" 树是一种非线性数据结构，主要用于描述带有层次关系的数据集。树的形式化定义是：树是由一个或多个结点组成的有限集合，其中有一个特定的称为根的结点；其余结点可分为m(m≥0)个互不相交的...
树与二叉树的转换
01-08
树与二叉树之间的转换是一个重要的概念，尤其是在数据结构和算法的学习中。下面我们将详细探讨这个主题。 一、树到二叉树的转换 1. 顺序遍历法：树转换为二叉树的主要方法是通过前序遍历（Preorder Traversal）、...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5126
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
函数模板与类模板
程序员_小兵
07-12 1565
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
算法014：找到字符串中所有字母异位词
最新发布
m0_62319039的博客
07-14 414
算法014：找到字符串中所有字母异位词
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 379
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 818
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值