【重点】【二叉树】剑指offer——面试题62：序列化二叉树(297.二叉树的序列化与反序列化)

力扣链接1：https://leetcode.cn/problems/xu-lie-hua-er-cha-shu-lcof/description/
力扣297

最佳做法：前序遍历

参考链接：https://leetcode.cn/problems/xu-lie-hua-er-cha-shu-lcof/solutions/832188/xu-lie-hua-er-cha-shu-by-leetcode-soluti-4duq/

Python

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        res = list()
        self.mySerialize(root, res)
        return ",".join(res)
        
    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        array = data.split(",")
        root = self.myDeserialize(array)
        return root

    def mySerialize(self, root, res):
        if not root:
            res.append("None")
            return
        res.append(str(root.val))
        self.mySerialize(root.left, res)
        self.mySerialize(root.right, res)

    def myDeserialize(self, array):
        top1_val = array[0]
        array.pop(0)
        if top1_val == "None":
            return None
        root = TreeNode(int(top1_val))
        root.left = self.myDeserialize(array) # 进入构建左子树的递归时, 左子树的值就被删了, 剩下的就是右子树的值
        root.right = self.myDeserialize(array)
        return root

# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))

Java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        StringBuilder s = new StringBuilder("");
        mySerialize(root, s);
        return s.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        String[] array = data.split(",");
        LinkedList<String> list = new LinkedList<>(Arrays.asList(array));
        return myDeserialize(list);
    }

    public void mySerialize(TreeNode node, StringBuilder s) {
        if (node == null) {
            s.append("null,");
        } else {
            s.append(node.val + ",");
            mySerialize(node.left, s);
            mySerialize(node.right, s);
        }
    }

    public TreeNode myDeserialize(LinkedList<String> list) {
        if (list.get(0).equals("null")) {
            list.remove(0);
            return null;
        }
        String firstValStr = list.remove(0); // 不必担心list为空，因为最后字符一定是null
        TreeNode node = new TreeNode(Integer.parseInt(firstValStr));
        node.left = myDeserialize(list);
        node.right = myDeserialize(list);
        return node;
    }

}

// Your Codec object will be instantiated and called as such:
// Codec codec = new Codec();
// codec.deserialize(codec.serialize(root));

##Solution1:
参考网址：https://www.nowcoder.com/profile/6475323/codeBookDetail?submissionId=19293787
书上的思路。理解记忆~

/*
 1. 对于序列化：使用前序遍历，递归的将二叉树的值转化为字符，并且在每次二叉树的结点
不为空时，在转化val所得的字符之后添加一个' ， '作为分割。对于空节点则以 '#' 代替。
 2. 对于反序列化：按照前序顺序，递归的使用字符串中的字符创建一个二叉树(特别注意：
在递归时，递归函数的参数一定要是char ** ，这样才能保证每次递归后指向字符串的指针会
随着递归的进行而移动！！！)
*/
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
 public:
    char* Serialize(TreeNode *root) { //序列化接口函数
         if (root == NULL)
             return NULL;
         string str;
         my_serialize(root, str);
         //字符串转char *
         char *ret = new char[str.length() + 1];
         for (int i = 0; i < str.length(); i++)
             ret[i] = str[i];
         ret[str.length()] = '\0';
         return ret;
     }
    
     void my_serialize(TreeNode *root, string &str) {
         if (root == NULL) {
             str += '#';//用#代表null
             return;//返回上一层
         } else {
             string r = to_string(root->val);//值转字符串
             str += r;//字符串拼接
             str += ',';//数字后用，进行节点分隔
             my_serialize(root->left, str);
             my_serialize(root->right, str);
         }
     }
     
    TreeNode* Deserialize(char *str) {
        if (str == NULL)
            return NULL;
        TreeNode *res = deserialize(&str);
        return res;
    }
    
     TreeNode *deserialize(char **str) {
         if (**str == '#') { //空的时候返回
             ++(*str);
             return NULL;
         }
         int num = 0;
         while (**str != '\0' && **str != ',') {
             num = num * 10 + ((**str) - '0'); //求出每个节点的值
             ++(*str);
         }
         TreeNode *root = new TreeNode(num);
         if (**str == '\0')
             return root;
         else
             (*str)++;//跨过','
         root->left = deserialize(str);
         root->right = deserialize(str);
         return root;
     }
 };