Serialize and Deserialize BST solution and explanation

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Codec:

    def serialize(self, root):
        def preorder(node):
            return [str(node.val)] + preorder(node.left) + preorder(node.right) if node else []

        return ' '.join(preorder(root))

    def deserialize(self, data):
        if not data:
            return None

        def buildTree(bounds):
            if not data or not(bounds[0] < int(data[-1]) < bounds[1]):
                return None

            val = int(data.pop())
            node = TreeNode(val)
            node.right = buildTree((val, bounds[1]))
            node.left = buildTree((bounds[0], val))
            return node

        data = data.split()[::-1]
        return buildTree((-float('inf'), float('inf')))

#include <string>
#include <sstream>
#include <vector>
#include <climits>
#include <algorithm>

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Codec {
public:

    // Encodes a tree to a single string.
    std::string serialize(TreeNode* root) {
        std::string data;
        preorder(root, data);
        return data;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(std::string data) {
        std::istringstream iss(data);
        std::vector<int> nodes;
        std::string token;
        while (iss >> token) {
            nodes.push_back(std::stoi(token));
        }
        std::reverse(nodes.begin(), nodes.end());
        return buildTree(nodes, INT_MIN, INT_MAX);
    }

private:

    void preorder(TreeNode* node, std::string& data) {
        if (node) {
            data += std::to_string(node->val) + " ";
            preorder(node->left, data);
            preorder(node->right, data);
        }
    }

    TreeNode* buildTree(std::vector<int>& nodes, int lower, int upper) {
        if (nodes.empty() || nodes.back() < lower || nodes.back() > upper) {
            return nullptr;
        }

        int val = nodes.back();
        nodes.pop_back();
        TreeNode* node = new TreeNode(val);
        node->right = buildTree(nodes, val, upper);
        node->left = buildTree(nodes, lower, val);
        return node;
    }
};

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

import java.util.*;

public class Codec {

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

        StringBuilder sb = new StringBuilder();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node != null) {
                sb.append(node.val).append(",");
                queue.add(node.left);
                queue.add(node.right);
            } else {
                sb.append("null,");
            }
        }
        sb.setLength(sb.length() - 1);
        return sb.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if (data.equals("[]")) return null;

        String[] nodes = data.split(",");
        TreeNode root = new TreeNode(Integer.parseInt(nodes[0]));
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int i = 1;
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (!nodes[i].equals("null")) {
                node.left = new TreeNode(Integer.parseInt(nodes[i]));
                queue.add(node.left);
            }
            i++;
            if (!nodes[i].equals("null")) {
                node.right = new TreeNode(Integer.parseInt(nodes[i]));
                queue.add(node.right);
            }
            i++;
        }
        return root;
    }
}

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

var Codec = function() {};

Codec.prototype.serialize = function(root) {
  if (!root) return '[]';
  const queue = [root];
  let result = '';
  while (queue.length) {
    const node = queue.shift();
    if (node) {
      result += node.val + ',';
      queue.push(node.left);
      queue.push(node.right);
    } else {
      result += 'null,';
    }
  }
  return result.slice(0, -1);
};

Codec.prototype.deserialize = function(data) {
  if (data === '[]') return null;
  const nodes = data.split(',');
  const root = new TreeNode(parseInt(nodes[0]));
  const queue = [root];
  let i = 1;
  while (queue.length) {
    const node = queue.shift();
    if (nodes[i] !== 'null') {
      node.left = new TreeNode(parseInt(nodes[i]));
      queue.push(node.left);
    }
    i++;
    if (nodes[i] !== 'null') {
      node.right = new TreeNode(parseInt(nodes[i]));
      queue.push(node.right);
    }
    i++;
  }
  return root;
};

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

type Codec struct {
}

func Constructor() Codec {
	return Codec{}
}

// Serializes a tree to a single string.
func (this *Codec) serialize(root *TreeNode) string {
	if root == nil {
		return ""
	}
	data := &strings.Builder{}
	var dfs func(*TreeNode)
	dfs = func(root *TreeNode) {
		if root == nil {
			return
		}
		data.WriteString(strconv.Itoa(root.Val))
		data.WriteByte(' ')
		dfs(root.Left)
		dfs(root.Right)
	}
	dfs(root)
	return data.String()[0 : data.Len()-1]
}

// Deserializes your encoded data to tree.
func (this *Codec) deserialize(data string) *TreeNode {
	if data == "" {
		return nil
	}
	vals := strings.Split(data, " ")
	i := 0
	var dfs func(int, int) *TreeNode
	dfs = func(mi, mx int) *TreeNode {
		if i == len(vals) {
			return nil
		}
		x, _ := strconv.Atoi(vals[i])
		if x < mi || x > mx {
			return nil
		}
		i++
		root := &TreeNode{Val: x}
		root.Left = dfs(mi, x)
		root.Right = dfs(x, mx)
		return root
	}
	return dfs(math.MinInt64, math.MaxInt64)
}

/**
 * Your Codec object will be instantiated and called as such:
 * ser := Constructor()
 * deser := Constructor()
 * tree := ser.serialize(root)
 * ans := deser.deserialize(tree)
 * return ans
 */