字典树的序列化和反序列化

最新推荐文章于 2024-07-18 18:08:02 发布
最新推荐文章于 2024-07-18 18:08:02 发布
阅读量1k 收藏 2
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljp1919/article/details/76461257
版权

背景：

对于给定的一序列单词，在重建一棵字典树之后，将该树进行保留，实现进程之间的数据共享。

方案设计1：

常见的是采用struct或者class，作为节点信息和父子关系信息的存储。在子节点设计的时候采用指针数组的方式。

代码：

#include<cstdio>
#define MARKER ')'
#define N 26
using namespace std;
// A node of N-ary tree
struct Node {
   char key;
   Node *child[N];  // An array of pointers for N children
};

// A utility function to create a new N-ary tree node
Node *newNode(char key)
{
    Node *temp = new Node;
    temp->key = key;
    for (int i = 0; i < N; i++)
        temp->child[i] = NULL;
    return temp;
}
// This function stores the given N-ary tree in a file pointed by fp
void serialize(Node *root, FILE *fp)//先序遍历的方式
{
    // Base case
    if (root == NULL) return;

    // Else, store current node and recur for its children
    fprintf(fp, "%c ", root->key);//如果没有key字段呢？？而是位置信息作为
    for (int i = 0; i < N && root->child[i]; i++)
         serialize(root->child[i],  fp);

    // Store marker at the end of children
    fprintf(fp, "%c ", MARKER);
}

// This function constructs N-ary tree from a file pointed by 'fp'.
// This functionr returns 0 to indicate that the next item is a valid
// tree key. Else returns 0
int deSerialize(Node *&root, FILE *fp)
{
    // Read next item from file. If theere are no more items or next
    // item is marker, then return 1 to indicate same
    char val;
    if ( !fscanf(fp, "%c ", &val) || val == MARKER )
       return 1;

    // Else create node with this item and recur for children
    root = newNode(val);
    for (int i = 0; i < N; i++)
      if (deSerialize(root->child[i], fp))
         break;

    // Finally return 0 for successful finish
    return 0;
}

// A utility function to create a dummy tree shown in above diagram
Node *createDummyTree()
{
    Node *root = newNode('A');
    root->child[0] = newNode('B');
    root->child[1] = newNode('C');
    root->child[2] = newNode('D');
    root->child[0]->child[0] = newNode('E');
    root->child[0]->child[1] = newNode('F');
    root->child[2]->child[0] = newNode('G');
    root->child[2]->child[1] = newNode('H');
    root->child[2]->child[2] = newNode('I');
    root->child[2]->child[3] = newNode('J');
    root->child[0]->child[1]->child[0] = newNode('K');
    return root;
}

// A utlity function to traverse the constructed N-ary tree
//I use recursion method,and we also use a stack for the DFS
void traverse(Node *root)
{
    if (root)
    {
        printf("%c ", root->key);
        for (int i = 0; i < N; i++)
            traverse(root->child[i]);
    }
}

// Driver program to test above functions
int main()
{
    // Let us create an N-ary tree shown in above diagram
    Node *root = createDummyTree();

    // Let us open a file and serialize the tree into the file
    FILE *fp = fopen("tree.txt", "w");
    if (fp == NULL)
    {
        puts("Could not open file");
        return 0;
    }
    serialize(root, fp);
    fclose(fp);

    // Let us deserialize the storeed tree into root1
    Node *root1 = NULL;
    fp = fopen("tree.txt", "r");
    deSerialize(root1, fp);
    //test some nodes,and print relative keys
    printf("%c\n", root1->child[0]->key);//B
    printf("%c\n", root1->child[2]->child[1]->key);
    printf("%c\n", root1->child[2]->child[0]->key);
    printf("%c\n", root1->child[1]->key);

    printf("Constructed N-Ary Tree from file is:\n");
    traverse(root1);
    printf("\n");
    return 0;
}

上述代码所构建的树结构如下：

    A：
       |+--B:
            |+--E:
            |+--F:
            |+--K:
       |+--C:
       |+--D:
           |+--G:
           |+--H:
           |+--I:
           |+--J:

我们将整个深度优先遍历的结果存储在tree.txt中，这个就是序列化，通过这个tree.txt 结果再重建出树状结构就称为反序列化。
这里写图片描述

方案设计2：

采用vector取代数组对子节点列表进行存储,vector<Tree*> m_children。 另外，也可以用Tree **这样的二级指针来对子节点列表进行存储。

代码2：

#include<iostream>
#include<stack>
#include<queue>
#include<string.h>
#include<cassert>
#include<algorithm>
#include<cstdio>
using namespace std;
#define MARKER ')'
#define N 26
template<class TreeData>
struct Tree
{
    private:

        static int TreeDataCompare(Tree* op1, Tree* op2)
        {
            return op1->GetData() - op2->GetData();
        }

    public:
        Tree(TreeData data):
            m_data(data)
        {
        }
        Tree()//必要的初始化操作
        {}

    public:
        void AppendChild(Tree* child)
        {
            m_children.push_back(child);

            // sort children trees by treedata
//          sort(m_children.begin(), m_children.end(), TreeDataCompare);//是否对子树进行排序
        }

        Tree* PutChildByData(TreeData data)
        {
            // data already exists
            for(int i = 0; i < m_children.size(); i++)
                if(data == m_children[i]->GetData())
                    return m_children[i];

            // Append new child to children array
            Tree* newChild = new Tree(data);
            AppendChild(newChild);

            return newChild;
        }

        void PutPathByDataArray(const TreeData* szData)
        {
            if (*szData == 0)
                return;

            Tree* child = PutChildByData(*szData);

            child->PutPathByDataArray(szData+1);
        }

        // This function stores the given N-ary tree in a file pointed by fp
        void serialize(Tree *root, FILE *fp)
        {
            // Base case
            if (root == NULL) return;

            // Else, store current node and recur for its children
            fprintf(fp, "%c ", root->m_data);
            std::cout<<root->m_data<<" ";
            for (int i = 0; i < root->m_children.size() && root->m_children[i]; i++)
                 serialize(root->m_children[i],  fp);

            // Store marker at the end of children
            fprintf(fp, "%c ", MARKER);
        }
        // This function constructs N-ary tree from a file pointed by 'fp'.
        // This functionr returns 0 to indicate that the next item is a valid
        // tree key. Else returns 0
        int deSerialize(Tree *&root, FILE *fp)
        {
            // Read next item from file. If theere are no more items or next
            // item is marker, then return 1 to indicate same
            char val;
            if ( !fscanf(fp, "%c ", &val) || val == MARKER )
               return 1;

            root = newNode(val);//子序列需要分配空间？？否则无法进行递归调用。
            //但是子节点又不能是NULL
            //因为此时的vector的size是变动的
            for (int i = 0; i < N; i++)
            {
                root->m_children.push_back(NULL);//
//                root->m_children[i] = NULL;//是不行的因为数据插入的时候，是没有数据的，而遍历的时候才[]进行，[]是用以元素访问

                if (deSerialize(root->m_children[i], fp))
                    break;

            }
            // Finally return 0 for successful finish
            return 0;
        }
        // A utlity function to traverse the constructed N-ary tree
        void traverse(Tree *root)
        {
            if (root)
            {
                printf("%c ", root->m_data);
                for (int i = 0; i < root->m_children.size(); i++)
                    traverse(root->m_children[i]);
            }
        }
        //另一种方式的BFS遍历
        void MyBFS(Tree *root)
        {
            queue<Tree *> nodeQueue;  //使用C++的STL标准模板库
            nodeQueue.push(root);
            Tree *node;
            vector<int> numflag;
            int laynum=0;//记录层号
            numflag.push_back(1);//记录每层节点数量
            while(!nodeQueue.empty()){
                node = nodeQueue.front();
                nodeQueue.pop();
                std::cout<<node->m_data<<"->";
<<node->m_children.size()<<std::endl;//
                laynum++;
                int larycunt =0;
                int count_nodes=0;
                if(node->m_children.size() != 0)
                {
                    std::cout<<node->m_children.size()<<std::endl;//
                    count_nodes = count_nodes + node->m_children.size();//
                }
                for(i=0; i< node->m_children.size(); ++i)//遍历所有的子分支是否存在
                {
                    nodeQueue.push(node->m_children[i]);//循环的方式入队列
                    //记录下子节点所有的节点数，
                }
            }
            //json的方式对他们进行保留再以json方式进行打印
        }
    private:
        TreeData m_data;
        vector<Tree*> m_children;
    public:
        int GetChildrenNum()
        {
            return m_children.size();
        }

        Tree* GetChildByIndex(int index)
        {
            return m_children[index];
        }

        TreeData GetData()
        {
            return m_data;
        }

        // Fill children to the specified queue
        virtual void FillQueueWithChildren(queue<Tree*>& queue)
        {
            for(int i = 0; i < m_children.size(); i++)
            {
                if(m_children[i])
                    queue.push(m_children[i]);
            }
        }
};


template<class Tree>
class TraverseStack
{
    public:
        TraverseStack(Tree* tree):
            m_tree(tree)
        {
            m_tree->FillQueueWithChildren(m_children);
        }

        Tree* GetNextChild()
        {
            if (m_children.empty())
                return NULL;

            // pop head of the untraversed children queue
            Tree* head = m_children.front();
            m_children.pop();
            return head;
        }
        Tree* GetTree()
        {
            return m_tree;
        }
    private:
        Tree*           m_tree;
        queue<Tree*>    m_children;
};

template<class Tree>
class BFSTraverser
{
    public:
        BFSTraverser(Tree* root):m_root(root){}
        virtual ~BFSTraverser(){}
    public:
        typedef TraverseStack<Tree> PATHSTACKITEM;
        typedef vector<PATHSTACKITEM > PATHSTACK;
    public:
        virtual void Traverse()
        {
            m_pathStack.clear();
            // push the root stack item
            PATHSTACKITEM rItem(m_root);
            m_pathStack.push_back(rItem);

            while(!m_pathStack.empty())
            {
                PATHSTACKITEM& top = m_pathStack.back();
                Tree* nextChild = top.GetNextChild();
                if (!nextChild)
                {
                    // output pathStack
                    if(top.GetTree()->GetChildrenNum() == 0)
                        OutputStack();

                    // go back along the path to parent TraverseStack element
                    m_pathStack.pop_back();
                    continue;
                }

                assert(nextChild);

                // pre order output root‘s path
                if(nextChild == top.GetTree()->GetChildByIndex(0))
                    ;//OutputStack();

                // push new TraverseStack element to path
                PATHSTACKITEM newStackItem(nextChild);

                // enlonger the current path to the untraversed child
                m_pathStack.push_back(newStackItem);
                continue;
            }
        }

        void OutputStack()
        {
            cout << m_pathStack[0].GetTree()->GetData();//打印根节点
            for(int i = 1; i < m_pathStack.size(); i++)
            {
                if(i>0)
                {
                    cout << m_pathStack[i].GetTree()->GetData();//其实位置信息本身就可以存储值
                    //思路不同，可以用vector也可以用二级指针的数组方式，但是vector需要用m_data存储数据，而二维数组的方式则是用位置信息记录了m_data的信息
                }
            }
            cout << endl;
        }

    private:
        Tree* m_root;
        PATHSTACK m_pathStack;

};

int main()
{
    Tree<char> test('a');
    Tree<char> test1('#');//
    Tree<char> test3('d');
    Tree<char> test2('c');
    Tree<char> test5('a');
    Tree<char> test4('e');
    test1.PutPathByDataArray("hello");
    test1.PutPathByDataArray("helkl");
    test.AppendChild(&test1);
    test.AppendChild(&test4);
    test.PutChildByData('m');//单个字母
    test1.PutChildByData('K');
    test4.PutChildByData('f');
    test4.PutChildByData('z');
    test4.PutChildByData('x');
    //通过string的方式进行添加
    BFSTraverser< Tree<char> > Travers(&test);
    Travers.Traverse();
    test.MyBFS(&test);
    return 0;

}

运行结果如下所示：
这里写图片描述

对于如果想要进行字典树进行序列化和反序列化话，如下：

int main()
{
    Tree<char> test('a');
    Tree<char> test1('d');//是一个空节点
    Tree<char> test3('d');
    Tree<char> test2('c');
    Tree<char> test5('a');
    Tree<char> test4('e');
    test1.PutPathByDataArray("hello");
    test1.PutPathByDataArray("helkl");
    test.AppendChild(&test1);
    test.AppendChild(&test4);
    test.PutChildByData('m');//单个字母
    test1.PutChildByData('K');
    test4.PutChildByData('f');
    test4.PutChildByData('z');
    test4.PutChildByData('x');
    //通过string的方式进行添加
    // Let us open a file and serialize the tree into the file
    FILE *fp = fopen("tree_new_1.txt", "w");
    if (fp == NULL)
    {
        puts("Could not open file");
        return 0;
    }
    printf("result of DFS:\n");
    test.serialize(&test, fp);
    printf("\n");
    fclose(fp);

    // Let us deserialize the storeed tree into root1
    Tree<char> *root1;
    Tree<char> NULLROOT('#');
    root1 = &NULLROOT;
    fp = fopen("tree_new_1.txt", "r");
    printf("Start deSerialize N-Ary Tree from file:\n");
    root1->deSerialize(root1, fp);

    printf("Traverse Constructed N-Ary Tree from file,result is:\n");
    root1->traverse(root1);
    return 0;

}

这里写图片描述
从上图可以看出重建的结果，即反序列化的结果和序列化的结果是一致的。
再检查下序列化的文件：
这里写图片描述
a d h e l l o ) ) k l ) ) ) ) ) K ) ) e f ) z ) x ) ) m ) )

JasonLiu1919
关注
专栏目录
JSON序列化与反序列化一个字典
lovegonghui的专栏
12-10 520
一、序列化一个字典 1.JSON序列化一个persons的Dictionary. using System; using System.Collections.Generic; using System.Linq; using System.Text; using Newtonsoft.Json; namespace JSONDemo { class Program
使用Xaml.XamlServices序列化或反序列化DependencyObject
04-02
XAML Services是.NET Framework的一部分，提供了对XAML的读写支持，允许开发者序列化和反序列化对象，包括`DependencyObject`。`DependencyObject`是WPF中所有依赖属性的基础类，它支持数据绑定、样式和模板等特性。...
序列化与反序列化之字典/列表/元组
测试小灰的博客
07-25 272
反序列化：把str类型转为python的数据类型。序列化：把python的数据类型转为str类型。二、列表的序列化与反序列化过程。三、 元组的序列化与反序列化过程。一、字典的序列化与反序列化。
数据结构之二叉树序列化/反序列化详解与示例（C, C++）
最新发布
qq_35320456的博客
07-18 1254
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的根节点没有父节点，而其他节点有一个父节点。序列化是将对象的状态信息转换为可以存储或传输的形式的过程。在二叉树的序列化中，通常将二叉树转换为一个字符串，以便存储或通过网络传输。反序列化是将序列化后的数据恢复为原始对象的过程。在二叉树的反序列化中，将字符串形式的数据转换回二叉树结构。在本文中，我们探讨了二叉树的基本概念、序列化与反序列化的定义及方法，并提供了C++代码示例。
Dictionary序列化和反序列化
weixin_30949361的博客
08-16 113
public class SerializeHelper { public static string XmlSerialize(List<CustomSearchEntity> obj) { XmlSerializer serializer = new XmlSerializer(); ...
【二叉树】树的序列化和反序列化【449. Serialize and Deserialize BST】
wlxsq的专栏
07-14 669
题目链接：https://leetcode.com/problems/serialize-and-deserialize-bst/#/description 树的序列化与反序列化(看完有惊喜0.0) 序列化参照https://leetcode.com/problems/construct-string-from-binary-tree/#/description 将树[2,1,3]转化成2(
字典的遍历方法+反序列化
brave_jcc的博客
03-12 329
[承接]http://blog.csdn.net/brave_jcc/article/details/79529012#python字典遍历的几种方法 #遍历key # 1 for key in model: print('键4',key,'-----','值:',model[key]) # 2 print('#############################') for key...
Json反序列化
10-24
JSON（JavaScript Object ...了解和掌握JSON反序列化的原理、常见库以及注意事项，对于提升开发效率和保证代码质量具有积极意义。在实际工作中，应根据项目需求选择合适的反序列化库，并编写测试用例确保其正确性。
寻找序列化的极限.pptx
10-09
《信息论》系列演讲稿 ... JSON的“噪音”与...序列化的极限、两个基本公理 UTF-8极限压缩 有理数：变长类型偏移术 字典压缩大法 尾部残缺问题 Ultra Pack与时空置换原理 V8引擎玄学（What's happening under
Trie树_字典树(字符串排序)简介及实现
10-26
Trie树，又称字典树、单词查找树，是一种用于处理字符串相关问题的高效数据结构。其核心思想是通过空间换时间，利用字符串的公共前缀来节约存储空间，并减少无谓的字符串比较，从而达到快速查找、插入和删除字符串的...
LeetCode第 57 场力扣夜喵双周赛（差分数组、单调栈） and 第 251 场力扣周赛（状态压缩动规，树的序列化，树哈希，字典树）
windyjcy的博客
07-27 421
LeetCode第 57 场力扣夜喵双周赛 离knight勋章越来越近，不过水平没有丝毫涨进 1941. 检查是否所有字符出现次数相同 题目描述 给你一个字符串 s ，如果 s 是一个 好 字符串，请你返回 true ，否则请返回 false 。 如果 s 中出现过的 所有 字符的出现次数 相同 ，那么我们称字符串 s 是 好 字符串。 示例 1： 输入：s = “abacbc” 输出：true 解释：s 中出现过的字符为 ‘a’，‘b’ 和 ‘c’ 。s 中所有字符均出现 2 次。 示例 2： 输入：s
理解字典树
陌离将离
04-28 323
字典树百度百科：又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希表高。性质：根节点不包含字符，除根节点外每一个节点都只包含一个字符； 从根节点到某一节点，路径上经过的字符连接起来，为该节...
反转单词序列
gkq_tt的博客
03-07 349
【题目】牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？ public String...
Python实现字典树-Trie
baidu_36146918的博客
05-06 1322
本篇文章将解释什么是字典树以及字典树的Python实现什么是字典树(Trie)节点设计数据结构设计实现 什么是字典树(Trie) 字典树是一种树型数据结构，通常用来存储大量字符串。字典树的每个节点通常都为一个字符。从根节点的第一个孩子节点开始到可以作为字符串结尾的节点的路径就是Trie所存储的字符串，这种存储方式带来的好处就是Trie的时间复杂度和存储字符串的数据量无关只与查询的字符串长度有关，这...
二叉树的序列化和反序列化
brucehb的专栏
01-07 3767
设计一个算法，并编写代码来序列化和反序列化二叉树。将树写入一个文件被称为“序列化”，读取文件后重建同样的二叉树被称为“反序列化”。 如何反序列化或序列化二叉树是没有限制的，你只需要确保可以将二叉树序列化为一个字符串，并且可以将字符串反序列化为原来的树结构。 样例 给出一个测试数据样例， 二叉树{3,9,20,#,#,15,7}，表示如下的树结构：
python网络爬虫 - 如何伪装逃过反爬虫程序
kelvingjy的博客
06-09 442
有的时候，我们本来写得好好的爬虫代码，之前还运行得Ok, 一下子突然报错了。 报错信息如下： Http 800 Internal internet error 这是因为你的对象网站设置了反爬虫程序，如果用现有的爬虫代码，会被拒绝。   之前正常的爬虫代码如下： from urllib.request import urlopen ... html = urlop
序列化和反序列化
wuguinianjing的博客
09-22 108
1. 什么是序列化？ 程序员在编写应用程序的时候往往需要将程序的某些数据存储在内存中，然后将其写入某个文件或是将它传输到网络中的另一台计算机上以实现通讯。这个将 程序数据转化成能被存储并传输的格式的过程被称为“序列化”（Serialization），而它的逆过程则可被称为“反序列化” （Deserialization）。 简单来说，序列化就是将对象实例的状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它根据流重构对象。这两个过程结合起来，可以轻 松地存储和传输数据。例如，可以序列化一个对象，然
python中的序列化与反序列化_详解Python 序列化Serialize 和 反序列化Deserialize
weixin_39812142的博客
12-20 741
详解Python 序列化Serialize 和 反序列化Deserialize详解Python 序列化Serialize 和 反序列化Deserialize序列化 (serialization)序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。序列化和反序列化的目的1、以某种存储形式使自定义对象持久化；2、将...
trie树(字典树)java实现
u012572955的专栏
05-06 3012
public class Trie{ private Node root; public Trie(){ root = new Node(' '); } public void insert(String word){ if(search(word) == true) return; Node curr
序列化边界：探索信息压缩与优化
Message Pack被介绍为一个二进制序列化格式，它兼容JSON且理论上更小、更快，采用Huffman编码方式，但存在Huffman树优化空间、类型变长编码冗余以及字典key约束等问题。 为了追求序列化的极限，提出了两个基本原则...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值