297. Serialize and Deserialize Binary Tree

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:

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

Example 2:

Input: root = []
Output: []

  Constraints:

• The number of nodes in the tree is in the range [0, 10^4].

• -1000 <= Node.val <= 1000

Solution (Java)

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

    private static final int BASE_OFFSET = 1000;
    private static final String DELIM = "*";
    private int offset;

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

    public void serialize(TreeNode root, StringBuilder sb) {
        // all nodes fit into 4 bits.
        // IFF we offset at 0. So encode(val) = val + min(default - 1000)
        if (root == null) {
            sb.append(DELIM);
            return;
        }
        String s = Integer.toHexString(root.val + BASE_OFFSET);
        StringBuilder sb2 = new StringBuilder();
        for (int i = 0; i < 3 - s.length(); i++) {
            sb2.append('0');
        }
        sb2.append(s);
        sb.append(sb2);
        serialize(root.left, sb);
        serialize(root.right, sb);
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if (data.charAt(offset) == '*') {
            offset++;
            return null;
        }
        TreeNode root =
                new TreeNode(
                        Integer.parseInt(data.substring(offset, offset + 3), 16) - BASE_OFFSET);
        offset += 3;
        root.left = deserialize(data);
        root.right = deserialize(data);
        return root;
    }
}

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

Solution (Javascript)

function TreeNode(val) {
  this.val = val
  this.left = null
  this.right = null
}


const serialize = (root) => {
  let current = [root]
  const result = []
  while (current.length) {
    const next = []
    current.forEach((node) => {
      result.push(node ? node.val : null)
      if (node) {
        next.push(node.left, node.right)
      }
    })
    current = next
  }
  return JSON.stringify(result)
}

/**
 * Decodes your encoded data to tree.
 *
 * @param {string} data
 * @return {TreeNode}
 */
const deserialize = (data = '') => {
  const list = JSON.parse(data)
  if (list.length === 0 || list[0] === null) {
    return null
  }
  const root = new TreeNode(list.shift())
  let current = [root]
  while (current.length > 0) {
    const next = []
    current.forEach((node) => {
      if (node !== null) {
        const leftValue = list.shift()
        const rightValue = list.shift()
        node.left = leftValue == null ? null : new TreeNode(leftValue)
        node.right = rightValue == null ? null : new TreeNode(rightValue)
        next.push(node.left, node.right)
      }
    })

    current = next
  }
  return root
}

Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).