Object-c 二叉树的遍历（前序、中序、后序以及非递归遍历）

• 二叉树的结构
  二叉树是树的特殊形式，它包含结点值（可空），左孩子结点（可空），右孩子结点（可空）。空树即三者均为空，当任一结点只有左孩子或右孩子时，这颗树的结构就与链表类似了。
• 定义一个二叉树的结点代码清单如下：

#import 

NS_ASSUME_NONNULL_BEGIN

@interface TreeNode : NSObject

@property(nonatomic,assign) NSInteger value;
@property(nonatomic,strong,nullable) TreeNode* leftChild;
@property(nonatomic,strong,nullable) TreeNode* rightChild;

-(instancetype) initWithData:(NSInteger) data;


@end

NS_ASSUME_NONNULL_END

• 创建一颗二叉树代码清单如下：

-(TreeNode*) createTree:(NSArray *)data{
    TreeNode* p1 = [[TreeNode alloc] initWithData:1];
    TreeNode* p2 = [[TreeNode alloc] initWithData:2];
    TreeNode* p3 = [[TreeNode alloc] initWithData:3];
    TreeNode* p4 = [[TreeNode alloc] initWithData:4];
    TreeNode* p5 = [[TreeNode alloc] initWithData:5];
    TreeNode* p6 = [[TreeNode alloc] initWithData:6];
    TreeNode* p7 = [[TreeNode alloc] initWithData:7];
    TreeNode* p8 = [[TreeNode alloc] initWithData:8];
    TreeNode* p9 = [[TreeNode alloc] initWithData:9];
    p1.leftChild = p2;
    p1.rightChild = p3;
    p2.leftChild = p4;
    p2.rightChild = p5;
    p3.leftChild = p6;
    p3.rightChild = p7;
    p4.leftChild = p8;
    p4.rightChild = p9;
    self.root = p1;
    return p1;
}

对应的树抽象结构为：

• 二叉树的前序遍历（递归）规则为：根，左，右

1.先访问根结点，如果有左孩子结点再访问左孩子结点，如果有右孩子结点再访问右孩子结点。
2.然后再把左孩子结点当作根结点，重复一次步骤1。
3.再把右孩子结点当作根结点，重复一次步骤1。
4.直到当前结点为叶子结点为止。
前序遍历的结果为：1，2，4，8，9，5，3，6，7

*前序遍历（递归方式）代码为：

-(void) preOrder:(TreeNode *)root{
    if (!root) {
        return;
    }
    [self visitedNode:root];
    if(root.leftChild){
        [self preOrder:root.leftChild];
    }
    if(root.rightChild){
        [self preOrder:root.rightChild];
    }
}

• 前序遍历(非递归借助栈实现）具体实现逻辑如下：

1.根结点入栈
2.while栈不为空时，取栈顶元素（假设为e）并访问。判断e是否有左孩子结点，如果有则入栈，判断e是否有右孩子结点，如果有则入栈。

• 前序遍历(非递归借助栈实现）代码清单为：

/// 非递归实现前序遍历
/// @param root 根结点
-(void) iterativePreOrder:(TreeNode*) root{
    
    if (!self.stack) {
        self.stack = [[Stack alloc] initWithSize:100];
    }
    TreeNode* p = root;
    if(p){
        printf(" \n前序非递归遍历的结果为:\n ");
        [self.stack push:p];
        while (![self.stack isEmpty]) {
            p = (TreeNode*)[self.stack pop];
            [self visitedNode:p];
            
            if(p.rightChild){
                [self.stack push:p.rightChild];
            }
            if(p.leftChild){
                [self.stack push:p.leftChild];
            }
            
        }
    }
}

• 二叉树的中序遍历（递归）规则为：左，根，右

1.对树中任一结点判断当前结点是否有左孩子，如果有左孩子，继续寻找，直到当前结点没有左孩子为止才访问。
2.访问当前结点的父结点。
3.访问当前结点的右孩子结点。
4.直到当前结点为叶子结点为止。
中序遍历的结果为：8，4，9，5，2，1，6，3，7

• 二叉树的中序遍历（递归）代码为：

-(void) inOrder:(TreeNode *)root{
    if (!root) {
        return;
    }
    if(root.leftChild){
        [self inOrder:root.leftChild];
    }
    [self visitedNode:root];
    if(root.rightChild){
        [self inOrder:root.rightChild];
    }
}

• 二叉树的中序遍历（非递归)逻辑如下：

对于任一结点P，
1.若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；
2.若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；
3.直到P为nil或者栈为空则遍历结束。

• 二叉树的中序遍历（非递归)代码清单如下：

/// 非递归实现中序遍历
/// @param root 根结点
-(void) iterativeInOrder:(TreeNode*) root{
    if (!self.stack) {
        self.stack = [[Stack alloc] initWithSize:100];
    }
    printf(" \n中序非递归遍历的结果为:\n ");
    TreeNode* p = root;
    while (p || ![self.stack isEmpty]) {
        
        while (p) {
            [self.stack push:p];
            p = p.leftChild;
        }
        if (![self.stack isEmpty]) {
            p = (TreeNode*)[self.stack pop];
            [self visitedNode:p];
            p = p.rightChild;
        }
    }
}

• 二叉树的后序遍历（递归）规则为：左，右，根

1.对树中任一结点判断当前结点是否有左孩子，如果有左孩子，继续寻找，直到当前结点没有左孩子为止才访问。
2.访问当前结点的右孩子结点。
3.访问当前结点的父亲结点。
4.直到当前结点为叶子结点为止。
后序遍历的结果为：8，9，4，5，2，6，7，3，1

• 二叉树的后序遍历（递归）代码清单：

-(void) postOrder:(TreeNode *)root{
    if (!root) {
        return;
    }
    if(root.leftChild){
        [self postOrder:root.leftChild];
    }
    if(root.rightChild){
        [self postOrder:root.rightChild];
    }
    [self visitedNode:root];
}

• 二叉树的后序遍历（非递归）逻辑：

1.要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；
2.或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

• 二叉树的后序遍历（非递归）代码清单：

/// 非递归实现后序遍历
/// @param root 根结点
-(void) iterativePostOrder:(TreeNode*) root{
    if (!self.stack) {
           self.stack = [[Stack alloc] initWithSize:100];
     }
    [self.stack push:root];
    TreeNode* cur;
    TreeNode* pre;
    printf(" \n后序非递归遍历的结果为:\n ");
    while(![self.stack isEmpty]){
        cur = (TreeNode*)[self.stack top];
        
        //没有孩子结点
        BOOL noChild = !cur.leftChild && !cur.rightChild;
        //通过判断上一个结点是否为其中的一个孩子结点时，来判断孩子结点是否都已经被访问过
        //如果当前结点存在左右孩子那么必须等它左右孩子都必需访问之后才能访问它
        BOOL lastVisitedNode = pre && ([pre isEqual:cur.leftChild] || [pre isEqual: cur.rightChild]);
        if (noChild || lastVisitedNode) {
            [self visitedNode:cur];
            [self.stack pop];
            pre = cur;
        }else{
            if(cur.rightChild){
                [self.stack push:cur.rightChild];
            }
            if(cur.leftChild){
                [self.stack push:cur.leftChild];
            }
        }
    }
}

-(void) visitedNode:(TreeNode*)node{
    if (node) {
        printf(" %ld ",node.value);
    }
}