LeetCode 297. Serialize and Deserialize Binary Tree

ID	Title	Difficulty
1	Two Sum	Easy
2	Add Two Numbers	Medium
3	Longest Substring Without Repeating Characters	Medium
4	Median of Two Sorted Arrays	Hard
5	Longest Palindromic Substring	Medium
6	Zigzag Conversion	Medium
7	Reverse Integer	Medium
8	String to Integer (atoi)	Medium
9	Palindrome Number	Easy
10	Regular Expression Matching	Hard
11	Container With Most Water	Medium
12	Integer to Roman	Medium
13	Roman to Integer	Easy
14	Longest Common Prefix	Easy
15	3Sum	Medium
16	3Sum Closest	Medium
17	Letter Combinations of a Phone Number	Medium
18	4Sum	Medium
19	Remove Nth Node From End of List	Medium
20	Valid Parentheses	Easy
21	Merge Two Sorted Lists	Easy
22	Generate Parentheses	Medium
23	Merge k Sorted Lists	Hard
24	Swap Nodes in Pairs	Medium
25	Reverse Nodes in k-Group	Hard
26	Remove Duplicates from Sorted Array	Easy
27	Remove Element	Easy
28	Find the Index of the First Occurrence in a String	Easy
29	Divide Two Integers	Medium
30	Substring with Concatenation of All Words	Hard
31	Next Permutation	Medium
32	Longest Valid Parentheses	Hard
33	Search in Rotated Sorted Array	Medium
34	Find First and Last Position of Element in Sorted Array	Medium
35	Search Insert Position	Easy
36	Valid Sudoku	Medium
37	Sudoku Solver	Hard
38	Count and Say	Medium
39	Combination Sum	Medium
40	Combination Sum II	Medium
41	First Missing Positive	Hard
42	Trapping Rain Water	Hard
43	Multiply Strings	Medium
44	Wildcard Matching	Hard
45	Jump Game II	Medium
46	Permutations	Medium
47	Permutations II	Medium
48	Rotate Image	Medium
49	Group Anagrams	Medium
50	Pow(x, n)	Medium

JIAKAOBO

LeetCode

感谢赞助!

㊗️
大家
offer
多多！

Problem

Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.

Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.

Clarification: The input/output format is the same as how LeetCode serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.

Example 1:

image tooltip here

Input: root = [1,2,3,null,null,4,5]
Output: [1,2,3,null,null,4,5]

Example 2:

Input: root = []
Output: []

Example 3:

Input: root = [1]
Output: [1]

Example 4:

Input: root = [1,2]
Output: [1,2]

Code

449, 652

public class Codec {
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        if (root == null) return "";

        StringBuilder res = new StringBuilder();

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node == null) {
                res.append("null ");
                continue;
            }

            res.append(node.val + " ");

            queue.offer(node.left);
            queue.offer(node.right);
        }

        return res.toString();

    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if (data == null || data.length() == 0) return null;

        String[] str = data.split(" ");
        TreeNode root = new TreeNode(Integer.parseInt(str[0]));
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        for (int i = 1; i < str.length; i++) {
            TreeNode node = queue.poll();

            if (!str[i].equals("null")) {
                node.left = new TreeNode(Integer.parseInt(str[i]));
                queue.offer(node.left);
            }

            i++;

            if (!str[i].equals("null")) {
                node.right = new TreeNode(Integer.parseInt(str[i]));
                queue.offer(node.right);
            }
        }
        return root;
    }
}