Cây (Tree)

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
 
# Tạo cây
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)

class TreeNode(
    var `val`: Int,
    var left: TreeNode? = null,
    var right: TreeNode? = null
)
 
// Tạo cây
val root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)

class TreeNode {
  int val;
  TreeNode? left, right;
  TreeNode(this.val, [this.left, this.right]);
}
 
// Tạo cây
var root = TreeNode(1);
root.left = TreeNode(2);
root.right = TreeNode(3);

class TreeNode {
    var val: Int
    var left: TreeNode?
    var right: TreeNode?
    init(_ val: Int) { self.val = val }
}
 
// Tạo cây
let root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)

class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int val) { this.val = val; }
}
 
// Tạo cây
TreeNode root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);

def inorder(root):
    if root:
        inorder(root.left)
        print(root.val, end=" ")
        inorder(root.right)

fun inorder(root: TreeNode?) {
    if (root != null) {
        inorder(root.left)
        print("${root.`val`} ")
        inorder(root.right)
    }
}

void inorder(TreeNode? root) {
  if (root != null) {
    inorder(root.left);
    print(root.val);
    inorder(root.right);
  }
}

func inorder(_ root: TreeNode?) {
    guard let root = root else { return }
    inorder(root.left)
    print(root.val, terminator: " ")
    inorder(root.right)
}

void inorder(TreeNode root) {
    if (root != null) {
        inorder(root.left);
        System.out.print(root.val + " ");
        inorder(root.right);
    }
}

from collections import deque
 
def level_order(root):
    if not root:
        return []
    
    result = []
    queue = deque([root])
    
    while queue:
        level = []
        for _ in range(len(queue)):
            node = queue.popleft()
            level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        result.append(level)
    
    return result

fun levelOrder(root: TreeNode?): List<List<Int>> {
    if (root == null) return emptyList()
    
    val result = mutableListOf<List<Int>>()
    val queue = ArrayDeque<TreeNode>()
    queue.addLast(root)
    
    while (queue.isNotEmpty()) {
        val level = mutableListOf<Int>()
        repeat(queue.size) {
            val node = queue.removeFirst()
            level.add(node.`val`)
            node.left?.let { queue.addLast(it) }
            node.right?.let { queue.addLast(it) }
        }
        result.add(level)
    }
    return result
}

List<List<int>> levelOrder(TreeNode? root) {
  if (root == null) return [];
  
  List<List<int>> result = [];
  Queue<TreeNode> queue = Queue()..add(root);
  
  while (queue.isNotEmpty) {
    List<int> level = [];
    int size = queue.length;
    for (int i = 0; i < size; i++) {
      TreeNode node = queue.removeFirst();
      level.add(node.val);
      if (node.left != null) queue.add(node.left!);
      if (node.right != null) queue.add(node.right!);
    }
    result.add(level);
  }
  return result;
}

func levelOrder(_ root: TreeNode?) -> [[Int]] {
    guard let root = root else { return [] }
    
    var result = [[Int]]()
    var queue = [root]
    
    while !queue.isEmpty {
        var level = [Int]()
        for _ in 0..<queue.count {
            let node = queue.removeFirst()
            level.append(node.val)
            if let left = node.left { queue.append(left) }
            if let right = node.right { queue.append(right) }
        }
        result.append(level)
    }
    return result
}

List<List<Integer>> levelOrder(TreeNode root) {
    if (root == null) return new ArrayList<>();
    
    List<List<Integer>> result = new ArrayList<>();
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    
    while (!queue.isEmpty()) {
        List<Integer> level = new ArrayList<>();
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();
            level.add(node.val);
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
        result.add(level);
    }
    return result;
}

def height(root):
    if not root:
        return 0
    return 1 + max(height(root.left), height(root.right))

fun height(root: TreeNode?): Int {
    if (root == null) return 0
    return 1 + maxOf(height(root.left), height(root.right))
}

int height(TreeNode? root) {
  if (root == null) return 0;
  return 1 + max(height(root.left), height(root.right));
}

func height(_ root: TreeNode?) -> Int {
    guard let root = root else { return 0 }
    return 1 + max(height(root.left), height(root.right))
}

int height(TreeNode root) {
    if (root == null) return 0;
    return 1 + Math.max(height(root.left), height(root.right));
}