Tree Sort

pick a language to open the code

class Node:
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None


def insert(node, key):
    if node is None:
        return Node(key)
    if key < node.key:
        node.left = insert(node.left, key)
    else:
        node.right = insert(node.right, key)
    return node


def inorder(node, out):
    if node is not None:
        inorder(node.left, out)
        out.append(node.key)
        inorder(node.right, out)


def tree_sort(values):
    root = None
    for value in values:
        root = insert(root, value)
    out = []
    inorder(root, out)
    return out

function makeNode(key) {
  return { key, left: null, right: null };
}

function insert(node, key) {
  if (node === null) return makeNode(key);
  if (key < node.key) node.left = insert(node.left, key);
  else node.right = insert(node.right, key);
  return node;
}

function inorder(node, out) {
  if (node === null) return;
  inorder(node.left, out);
  out.push(node.key);
  inorder(node.right, out);
}

function treeSort(values) {
  let root = null;
  for (const value of values) root = insert(root, value);
  const out = [];
  inorder(root, out);
  return out;
}

typedef struct Node {
    int key;
    struct Node *left, *right;
} Node;

static Node* insert(Node* node, int key) {
    if (node == NULL) {
        Node* fresh = calloc(1, sizeof(Node));
        fresh->key = key;
        return fresh;
    }
    if (key < node->key) node->left = insert(node->left, key);
    else node->right = insert(node->right, key);
    return node;
}

static void fill(Node* node, int a[], int* at) {
    if (node == NULL) return;
    fill(node->left, a, at);
    a[(*at)++] = node->key;
    fill(node->right, a, at);
}

void tree_sort(int a[], int n) {
    Node* root = NULL;
    for (int i = 0; i < n; i++) root = insert(root, a[i]);
    int at = 0;
    fill(root, a, &at);
}

struct Node {
    int key;
    Node* left = nullptr;
    Node* right = nullptr;
};

Node* insert(Node* node, int key) {
    if (node == nullptr) return new Node{key};
    if (key < node->key) node->left = insert(node->left, key);
    else node->right = insert(node->right, key);
    return node;
}

void fill(Node* node, std::vector<int>& out) {
    if (node == nullptr) return;
    fill(node->left, out);
    out.push_back(node->key);
    fill(node->right, out);
}

void tree_sort(std::vector<int>& v) {
    Node* root = nullptr;
    for (int value : v) root = insert(root, value);
    v.clear();
    fill(root, v);
}

class Node {
    public int Key;
    public Node Left, Right;
    public Node(int key) { Key = key; }
}

static Node Insert(Node node, int key) {
    if (node == null) return new Node(key);
    if (key < node.Key) node.Left = Insert(node.Left, key);
    else node.Right = Insert(node.Right, key);
    return node;
}

static int Fill(Node node, int[] a, int at) {
    if (node == null) return at;
    at = Fill(node.Left, a, at);
    a[at++] = node.Key;
    return Fill(node.Right, a, at);
}

static void TreeSort(int[] a) {
    Node root = null;
    foreach (int value in a) root = Insert(root, value);
    Fill(root, a, 0);
}

static class Node {
    int key;
    Node left, right;

    Node(int key) { this.key = key; }
}

static Node insert(Node node, int key) {
    if (node == null) return new Node(key);
    if (key < node.key) node.left = insert(node.left, key);
    else node.right = insert(node.right, key);
    return node;
}

static int fill(Node node, int[] a, int at) {
    if (node == null) return at;
    at = fill(node.left, a, at);
    a[at++] = node.key;
    return fill(node.right, a, at);
}

static void treeSort(int[] a) {
    Node root = null;
    for (int value : a) root = insert(root, value);
    fill(root, a, 0);
}