W3Schools Tryit Editor

Python

Java

#include <stdio.h>
#include <stdlib.h>

typedef struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

TreeNode* newTreeNode(int data) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}

void inOrderTraversal(TreeNode* node) {
    if (node == NULL)
        return;
    inOrderTraversal(node->left);
    printf("%d, ", node->data);
    inOrderTraversal(node->right);
}

TreeNode* minValueNode(TreeNode *node) {
    TreeNode *current = node;
    while (current && current->left != NULL) {
        current = current->left;
    }
    return current;
}

int main() {
    TreeNode* root = newTreeNode(13);
    root->left = newTreeNode(7);
    root->right = newTreeNode(15);

root->left->left = newTreeNode(3);
    root->left->right = newTreeNode(8);

root->right->left = newTreeNode(14);
    root->right->right = newTreeNode(19);

root->right->right->left = newTreeNode(18);

inOrderTraversal(root);
    printf("\n");

TreeNode *minNode = minValueNode(root);
    printf("Lowest value: %d\n", minNode->data);

return 0;
}

//C

public class Main {

public static class TreeNode {
        int data;
        TreeNode left;
        TreeNode right;

TreeNode(int data) {
            this.data = data;
            left = null;
            right = null;
        }
    }

public static void inOrderTraversal(TreeNode node) {
        if (node == null)
            return;
        inOrderTraversal(node.left);
        System.out.print(node.data + ", ");
        inOrderTraversal(node.right);
    }

public static TreeNode minValueNode(TreeNode node) {
        TreeNode current = node;
        while (current != null && current.left != null) {
            current = current.left;
        }
        return current;
    }

public static void main(String[] args) {
        TreeNode root = new TreeNode(13);
        root.left = new TreeNode(7);
        root.right = new TreeNode(15);

root.left.left = new TreeNode(3);
        root.left.right = new TreeNode(8);

root.right.left = new TreeNode(14);
        root.right.right = new TreeNode(19);

root.right.right.left = new TreeNode(18);

inOrderTraversal(root);
        System.out.println();

TreeNode minNode = minValueNode(root);
        System.out.println("Lowest value: " + minNode.data);
    }
}

// Java