Question

I haven’t implemented binary for a long time, and recently got a requirement to do that (to demonstrate some code), and I started using:

@interface NSNode : NSObject

@property (strong, nonatomic) NSNode *leftChild;
@property (strong, nonatomic) NSNode *rightChild;

but later on, it seems that whenever I need to do something to both nodes, I need to write it twice — once for the left child and once for the right child, unless if I make what needs to be done into an extra method, and pass the proper arguments carefully — there will be a lot of extra methods just to accomplish this.

If it had been done by using an NSMutableArray

typedef enum {
    NSNodeLeft = 0,
    NSNodeRight
} NSNodeLeftOrRightSide;

@interface NSNode : NSObject

@property (strong, nonatomic) NSMutableArray *children;

then I can always just use a loop to do something to both nodes:

for (NSNode *node in self.children) {
    // do something
}

Or if an index is needed to tell whether it is left or right child:

[self.children enumerateObjectsUsingBlock:
    ^(NSNode *node, NSUInteger nodeIndex, BOOL *stop) {
        // do something
    }
];

and the nodeIndex can be used to determined whether it is left or right child.

And what’s more, this class can be easily extend to a tree with N-children. Is this actually a better practice? Is there any disadvantage except for a very small performance for using array? (I chose NSMutableArray instead of NSArray because if we ever need to make this N-children, we don’t need to change it to NSMutableArray all over the place).

Answer 1

First, you should not use the name NSNode. Apple reserves NS prefix for its own use.

Second, just give your Node class its own enumerate message.

@interface Node : NSObject

- (void)enumerateChildrenUsingBlock:(void (^)(Node *child, NSUInteger childIndex, BOOL *stop))block;

// I prefer this shorter name style in my own classes:
- (void)forEachChild:(void (^)(Node *child, NSUInteger childIndex, BOOL *stop))block;

Implementing it is trivial:

@implementation Node

- (void)enumerateChildrenUsingBlock:(void (^)(Node *child, NSUInteger childIndex, BOOL *stop))block {
    BOOL stop = NO;
    block(self.leftChild, 0, &stop);
    if (!stop) {
        block(self.rightChild, 1, &stop);
    }
}

If you implement the NSFastEnumeration protocol, you can also write a for/in loop like this:

for (Node *child in parentNode) {
    // do something with child
}

You can implement NSFastEnumeration like this:

@interface Node : NSObject <NSFastEnumeration>
...

@implementation Node

- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(id *)stackbuf count:(NSUInteger)stackbufCount {
    // The compiler initializes state->state to 0 at the start of the for...in loop.
    // I use it to track which children have been returned.
    // 0 = no children returned yet
    // 1 = left children returned
    // 2 = both children returned

    state->itemsPtr = stackbuf;
    state->mutationsPtr = (__bridge unsigned long *)self;

    NSUInteger count = 0; // number of children I'm returning on this call
    if (state->state < 1 && count < stackbufCount) {
        stackbuf[count++] = self.leftChild;
        ++state->state;
    }
    if (state->state < 2 && count < stackbufCount) {
        stackbuf[count++] = self.rightChild;
        ++state->state;
    }

    return count;
}

Take a look at this article for more about fast enumeration: http://www.mikeash.com/pyblog/friday-qa-2010-04-16-implementing-fast-enumeration.html