Tree and graphs problems in Julia using struct data types, pointers and this - algorithm

Question

I want to write solve some graph/trees problems using Julia language.
Here is some good example. In C it was done this way:
Recursive C program for level order traversal of Binary Tree
#include <stdio.h>
#include <stdlib.h>
/* A binary tree node has data, pointer to left child
and a pointer to right child */
struct node
{
int data;
struct node *left, *right;
};
/* Function prototypes */
void printGivenLevel(struct node* root, int level);
int height(struct node* node);
struct node* newNode(int data);
/* Function to print level order traversal a tree*/
void printLevelOrder(struct node* root)
{
int h = height(root);
int i;
for (i=1; i<=h; i++)
printGivenLevel(root, i);
}
/* Print nodes at a given level */
void printGivenLevel(struct node* root, int level)
{
if (root == NULL)
return;
if (level == 1)
printf("%d ", root->data);
else if (level > 1)
{
printGivenLevel(root->left, level-1);
printGivenLevel(root->right, level-1);
}
}
/* Compute the "height" of a tree -- the number of
nodes along the longest path from the root node
down to the farthest leaf node.*/
int height(struct node* node)
{
if (node==NULL)
return 0;
else
{
/* compute the height of each subtree */
int lheight = height(node->left);
int rheight = height(node->right);
/* use the larger one */
if (lheight > rheight)
return(lheight+1);
else return(rheight+1);
}
}
/* Helper function that allocates a new node with the
given data and NULL left and right pointers. */
struct node* newNode(int data)
{
struct node* node = (struct node*)
malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
/* Driver program to test above functions*/
int main()
{
struct node *root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
printf("Level Order traversal of binary tree is \n");
printLevelOrder(root);
return 0;
}
I have tried to do it in Julia in similar way, but there are some problems, especially with accessing to struct elements.(like node->right and node->left).
Or some way to create Self-referential struct and function to allocate nodes.
struct node
data::Int
left::Ptr{node}
right::Ptr{node}
end
# Compute the "height" of a tree -- the number of
# nodes along the longest path from the root node
# down to the farthest leaf node.
function height = (node::Ptr{node})
if node === nothing
return 0
else
# compute the height of each subtree
lheight = height(node->left)
rheight = height(node->right)
# use the larger one
if lheight > rheight
return lheight+1
else return rheight+1
end
end
end
From what I've seen trying to recreate a problem solution in C way isn't the way, however this struct type should be useful. I just have to know how to create self-referent struct, how to allocate elements in this node and how to get them.

Answer 1

First of all, I would strongly suggest reading through https://docs.julialang.org/en/v1/, since Julia is different from C in quite a few ways. There are multiple things to point out here:
Per default structs in Julia are immutable, which means you cannot modify fields after it is created. It is also always passed by copy instead of by reference, since it doesn't have a specific memory address and usually gets allocated on the stack. This actually has multiple benefits for the compiler and is part of the reason why Julia can be so fast. In your example you probably want a mutable struct, which is more similar a struct in C.
In Julia, you should never have to use pointers (Ptr) directly, unless you are calling C code. Since Julia uses a garbage collector, raw pointers have a lot of gotchas when it comes to memory management and should generally just be avoided. You usually just work with objects directly or, if you want to pass immutable objects by reference, you can wrap them in Ref.
In Julia, fields are always accessed either just with a dot x.field (equivalent to getproperty(x, :field)), or in some cases getfield(x, :field). (The latter can't be overloaded by the user, which is sometimes useful). -> actually creates an anonymous function.
For your example the following should work instead:
mutable struct Node
data::Int
left::Node
right::Node
Node(data::Int) = new(data)
end
function height(node::Node, field::Symbol)
isdefined(node, field) || return 0
return height(getproperty(node, field))
end
function height(node::Node)
lheight = height(node, :left)
rheight = height(node, :right)
# use the larger one
if lheight > rheight
return lheight+1
else
return rheight+1
end
end
What the first part is doing is creating a mutable struct Node, with self-referential fields like your C example. The line Node(data::Int) = new(data) is actually an inner constructor taking just the data and if you call new directly in a mutable struct, you can leave trailing fields undefined. You can define these fields afterwards with x.field = y. If these fields are themselves mutable, you can also check if they are undefined with isdefined(x, :field). Here, I am adding another method to height, which also takes a field name, which returns the height of the field if it's defined and 0 otherwise.
You would then construct nodes and calculate their height like this:
julia> n = Node(1)
Node(1, #undef, #undef)
julia> n.left=Node(2)
Node(2, #undef, #undef)
julia> n
Node(1, Node(2, #undef, #undef), #undef)
julia> height(n)
2
Hope that helps! If you want to learn more, the documentation I linked above is usually quite good.