777879808182838485

using System;
using System.Collections.Generic;

// Definition for a binary tree node.
public class TreeNode {
    public int Data;
    public TreeNode Left;
    public TreeNode Right;
    public TreeNode(int val = 0, TreeNode left = null, TreeNode right = null) {
        Data = val;
        Left = left;
        Right = right;
    }
}
 
public class Solution {
    private int k;
    private int result;

    // Helper function for inorder traversal
    private void Inorder(TreeNode node) {
        if (node != null) {
            Inorder(node.Left);
            if (--k == 0) {
                result = node.Data;
                return;
            }
            Inorder(node.Right);
        }
    }

    // Helper function for reverse inorder traversal
    private void ReverseInorder(TreeNode node) {
        if (node != null) {
            ReverseInorder(node.Right);
            if (--k == 0) {
                result = node.Data;
                return;
            }
            ReverseInorder(node.Left);
        }
    }

    // Function to find the kth smallest element
    public int KthSmallest(TreeNode root, int k) {
        this.k = k;
        this.result = -1;
        Inorder(root);
        return result;
    }

    // Function to find the kth largest element
    public int KthLargest(TreeNode root, int k) {
        this.k = k;
        this.result = -1;
        ReverseInorder(root);
        return result;
    }

    // Function to return kth smallest and kth largest elements
    public List<int> KLargesSmall(TreeNode root, int k) {
        return new List<int> { KthSmallest(root, k), KthLargest(root, k) };
    }
}


public class Program {
    public static void Main() {
        // Constructing the tree: [3, 1, 4, null, 2]
        TreeNode root = new TreeNode(3) {
            Left = new TreeNode(1) {
                Right = new TreeNode(2)
            },
            Right = new TreeNode(4)
        };

        Solution solution = new Solution();
        int k = 1;
        List<int> result = solution.KLargesSmall(root, k);

        // Output the result
        Console.WriteLine($"[{result[0]}, {result[1]}]");  // Output: [1, 4]
    }
}

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354

package main

import "fmt"

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

// Function to find the kth smallest element
func kthSmallest(root *TreeNode, k int) int {
    var ks = k
    var result = -1

    // Helper function for inorder traversal
    var inorder func(node *TreeNode)
    inorder = func(node *TreeNode) {
        if node != nil {
            inorder(node.Left)
            ks-- // --k in C++
            if ks == 0 {
                result = node.Val
                return
            }
            inorder(node.Right)
        }
    }

    inorder(root)
    return result
}

// Function to find the kth largest element
func kthLargest(r