https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/

    1. /**
    2.  * Definition for a binary tree node.
    3.  * function TreeNode(val) {
    4.  *     this.val = val;
    5.  *     this.left = this.right = null;
    6.  * }
    7.  */
    9. /**
    10.  * Encodes a tree to a single string.
    11.  *
    12.  * @param {TreeNode} root
    13.  * @return {string}
    14.  */
    15. var serialize = function(root) {
    16.     const queue = [root];
    17.   let res = [];
    18.   while (queue.length) {
    19.     const node = queue.shift(); // 考察出列的节点
    20.     if (node) {                 // 是真实节点，带出子节点入列
    21.       res.push(node.val);       // 节点值推入res
    22.       queue.push(node.left);    // 子节点入列，不管是不是null节点都入列
    23.       queue.push(node.right);    
    24.     } else {                    // 是null节点，没有子节点入列
    25.       res.push('X');            // X 推入res
    26.     }
    27.   }
    28.   return res.join(',');  // 转成字符串
    29. };
    31. /**
    32.  * Decodes your encoded data to tree.
    33.  *
    34.  * @param {string} data
    35.  * @return {TreeNode}
    36.  */
    37. var deserialize = function(data) {
    38.      if (data == 'X') return null;
    40.   const list = data.split(',');  // 序列化字符串split成数组
    42.   const root = new TreeNode(list[0]); // 获取首项，构建根节点
    43.   const queue = [root];          // 根节点推入队列
    44.   let cursor = 1;                // 初始指向list第二项
    46.   while (cursor < list.length) { // 指针越界，即扫完了序列化字符串
    47.     const node = queue.shift();  // 考察出列的节点
    49.     const leftVal = list[cursor];      // 它的左儿子的值
    50.     const rightVal = list[cursor + 1]; // 它的右儿子的值
    52.     if (leftVal != 'X') {              // 是真实节点
    53.       const leftNode = new TreeNode(leftVal); // 创建左儿子节点
    54.       node.left = leftNode;                   // 认父亲
    55.       queue.push(leftNode);                   // 自己也是父亲，入列
    56.     }
    57.     if (rightVal != 'X') {
    58.       const rightNode = new TreeNode(rightVal);
    59.       node.right = rightNode;
    60.       queue.push(rightNode);
    61.     }
    62.     cursor += 2; // 一次考察一对儿子，指针加2
    63.   }
    64.   return root;  // BFS结束，构建结束，返回根节点
    65. };
    67. /**
    68.  * Your functions will be called as such:
    69.  * deserialize(serialize(root));
    70.  */
    1. function serialize(root: TreeNode | null): string {
    2.     let res: string = '['
    3.     let queue: TreeNode[] = []
    4.     if (root === null) return ''
    5.     queue.push(root)
    6.     while (queue.length) {
    7.         let curr = queue.pop()!
    8.         if (curr === null) res += 'null'
    9.         else {
    10.             res += curr.val + ','
    11.             if (curr.left) queue.push(curr.left)
    12.             if (curr.right) queue.push(curr.right)
    13.         }
    14.     }
    15.     res.substring(0, res.length - 1);
    16.     res += ']'
    17.     return res
    19. };
    21. function deserialize(data: string): TreeNode | null {
    22.     let str = data.substring(1, data.length - 1);
    23.     let arr = str.split(',')
    24.     let root = new TreeNode(Number(arr[0]))
    25.     let queue: TreeNode[] = []
    26.     let parent: TreeNode = root // 当前节点的父节点
    27.     let isLeft = true; // 是不是左边节点
    28.     for (let i = 1; i < arr.length; i++) {
    29.         let curr = getNode(arr[i])
    30.         if (isLeft) parent.left = curr
    31.         else parent.right = curr
    33.         if (curr != null){
    34.             queue.push(curr)
    35.         }
    36.         isLeft = !isLeft
    37.         if (isLeft) queue.pop()
    39.     }
    40.     return root
    41. };
    43. function getNode(val: string): TreeNode | null {
    44.     if (val === 'null') {
    45.         return null
    46.     } else {
    47.         return new TreeNode(Number(val))
    48.     }
    49. }