Question

I have made a tree structure using c and used it for storing some moves of a chess game.
my structure is

struct node{
        NSString *comment;
        NSString *move;
        struct node *variationLink;
        struct node *nextLink;
        struct node *goBack;
    };

i create node using malloc.When the game is changed or unloaded i want to release the tree is there any way to do it in dalloc or i have to make a function to reach each node and free it?

Answer 1

You need to create a function that recursively frees the structure, something like:

void free_nodes(struct node *n)
{
    if (n != NULL)
    {
        free_nodes(n->nextLink);
        free_nodes(n->variationLink);
        [n->comment release];
        [n->move release];
        free(n);
    }
}

and then just call that from within your dealloc method:

- (void)dealloc
{
    free_nodes(_root_node);
    [super dealloc];
}

Other comments:

• You’ll want a link back to the mainline of a variation, which is equivalent to the goBack pointer, but for variations. This will allow you to transverse back to the mainline of any node, as at the moment there is no way of performing full transversal of your tree.
• I would rename goBack to prev, nextLink to next and variationLink to variation, but that’s up to you really.
• You need to store the move using an internal format, not as an NSString. The strings should only be generated during display (in the view’s draw method). This allows you to actually use the move data rather than having to parse the string again (very expensive) and doing the string conversion only during display allows you to change how the move string is generated based on user preferences (short algebraic notation, long algebraic notation, co-ordinate notation, using piece character fonts rather than letters, etc.).

Edit after question from OP: In order to allow your tree to store multiple variations you need to create doubly-linked list of variations. Therefore the node will be part of two doubly-linked lists. Writing this in C++ will help, but I’ll show it in C, if that’s what you are using:

typedef struct node
{
    Move move;    // Holds the move (this can be done using a 32-bit unsigned integer).
    struct node *prev;
    struct node *next;
    struct node *variation;
    struct node *mainline;
    NSString *comment;
} Node;

Here the mainline link points to the previous variation, which is NULL if this is the mainline move.

The moves 1.e4 e5 (1…Nf6 a4) (1…Nc6 b4) 2.Nc3 would be held using a tree like this (if links are not shown on a node then they are NULL):

I am using this approach in a chess program I am developing and it’s working very well. To re-iterate; I separate the data (this node) from the presentation (the string containing the move text which is displayed in the UI). The generated move strings should be held in a different way altogether; perhaps Core Text, but I am using a custom method.