这链式存储结构树的代码，我以前还真写过，不过具体细节有点模糊了。我那时候是2019年，在一家初创公司做项目，用Java实现的。主要就是为了管理一些产品数据，方便搜索和更新。
java class TreeNode { int value; TreeNode left; TreeNode right;
TreeNode(int value) { this.value = value; this.left = null; this.right = null; } }
public class BinarySearchTree { private TreeNode root;
public BinarySearchTree() { root = null; }
public void insert(int value) { root = insertRecursive(root, value); }
private TreeNode insertRecursive(TreeNode current, int value) { if (current == null) { return new TreeNode(value); }
if (value < current.value) { current.left = insertRecursive(current.left, value); } else if (value > current.value) { current.right = insertRecursive(current.right, value); } else { // value already exists return current; }
return current; }
// ... 其他方法，比如 search、delete 等 ... }
这个树结构就是最基本的二叉搜索树（BST），它保证了左子树上所有节点的值均小于它的根节点的值，右子树上所有节点的值均大于它的根节点的值。不过，这代码里的 search 和 delete 方法我忘了，得回去翻翻。
，对了，那个项目最后虽然没成功，但那段时间还是学到不少东西的。😄

python class TreeNode: def init(self, value): self.value = value self.left = None self.right = None
def inorder_traversal(root): if root: inorder_traversal(root.left) print(root.value, end=' ') inorder_traversal(root.right)
# 创建一个链式存储结构的树 root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(3) root.left.left = TreeNode(4) root.left.right = TreeNode(5)
# 执行中序遍历 inorder_traversal(root)
实操提醒：确保树节点类中有指向左右子节点的引用。

2023，北京，某大型互联网公司
python class TreeNode: def init(self, x): self.val = x self.left = None self.right = None
class Tree: def init(self): self.root = None
def insert(self, val): if not self.root: self.root = TreeNode(val) else: self._insert_recursive(self.root, val)
def _insert_recursive(self, node, val): if val < node.val: if not node.left: node.left = TreeNode(val) else: self._insert_recursive(node.left, val) else: if not node.right: node.right = TreeNode(val) else: self._insert_recursive(node.right, val)
def search(self, val): return self._search_recursive(self.root, val)
def _search_recursive(self, node, val): if not node: return False if node.val == val: return True elif val < node.val: return self._search_recursive(node.left, val) else: return self._search_recursive(node.right, val)
# Example usage:

tree = Tree()

tree.insert(8)

tree.insert(3)

tree.insert(10)

tree.insert(1)

tree.insert(6)

tree.insert(14)

print(tree.search(6)) # Output: True

print(tree.search(7)) # Output: False

c typedef struct TreeNode { int value; struct TreeNode left; struct TreeNode right; } TreeNode;
TreeNode createNode(int value) { TreeNode node = (TreeNode)malloc(sizeof(TreeNode)); node->value = value; node->left = NULL; node->right = NULL; return node; }
void insertNode(TreeNode root, int value) { if (root == NULL) { root = createNode(value); } else if (value < (root)->value) { insertNode(&((root)->left), value); } else { insertNode(&((root)->right), value); } }
// 示例：创建一棵链式存储结构的树，插入5个节点 TreeNode root = NULL; insertNode(&root, 10); insertNode(&root, 5); insertNode(&root, 15); insertNode(&root, 3); insertNode(&root, 7);