树

一.完全二叉树：子节点只存在左右节点的树。下标特征：父节点＝子节点/2。

二.最小堆：从根节点开始，由小到大展开的完全二叉树。

三.二叉排序树（又名二叉搜索树）：左节点都小于父节点，右节点都大于父节点的二叉树。（常用中根遍历）

四.核心：二叉树的遍历（前序、中序、后序），遍历二叉树通用方法使用分治的思想，时间复杂度与节点个数有关，O(n) n表示递归次数。

按1到13的顺序排下去的二叉树，遍历分别

　　begin

／     前序

middle  —  end         前序：1 － 2、4、8、9、5、10、11 － 3、6、12、13、7

 

　　middle

／　 中序　  \

begin        end          中序：8、4、9、2、10、5、11－1－12、6、13、3、7

 

　　　end

　　 后序　  \

begin  —  middle

1.前序遍历二叉树

#import "ViewController.h"

@interface TreeNote : NSObject

@property (nonatomic , assign) NSInteger val;

@property (nonatomic , weak) TreeNote *left;

@property (nonatomic , weak) TreeNote *right;

@end

@implementation TreeNote

@end

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
    TreeNote *rootTree = [[TreeNote alloc]init];
    rootTree.val = 1;
    
    TreeNote *rightTree = [TreeNote new];
    rightTree.val = 2;
    rootTree.right = rightTree;
    
    TreeNote *leftTree = [TreeNote new];
    leftTree.val = 3;
    rightTree.left = leftTree;
    
    //给出一棵二叉树，返回其节点值的前序遍历。
    NSArray *result = [self preorderTraversal:rootTree];
    NSLog(@"result = %@",result);
}


//Version 1:Traverse
//- (NSArray *)preorderTraversal:(TreeNote *)root
//{
//    NSMutableArray *result = [NSMutableArray array];
//    [self traverse:root result:result];
//    return result;
//}


- (void)traverse:(TreeNote *)root
          result:(NSMutableArray *)result
{
    if (root == nil) {
        return;
    }
    [result addObject:@(root.val)];
    [self traverse:root.left result:result];
    [self traverse:root.right result:result];
}


//Version 2: Divide & Conquer
//- (NSArray *)preorderTraversal:(TreeNote *)root
//{
//    NSMutableArray *result = [NSMutableArray array];
//    if (root == nil) {
//        return result;
//    }
//    //divide
//    NSArray *leftList = [self preorderTraversal:root.left];
//    NSArray *rightList = [self preorderTraversal:root.right];
//
//    //conquer
//    [result addObject:@(root.val)];
//    [result addObjectsFromArray:leftList];
//    [result addObjectsFromArray:rightList];
//
//    return result;
//}

//Version 0: Non-Recursion
- (NSArray *)preorderTraversal:(TreeNote *)root
{
    NSMutableArray *stack = [NSMutableArray array];
    NSMutableArray *result = [NSMutableArray array];
    
    [stack addObject:root];
    while (stack.count != 0)
    {
        TreeNote *node = stack.lastObject;
        [stack removeLastObject];
        [result addObject:@(node.val)];
        if (node.right != nil)
        {
            [stack addObject:node.right];
        }
        
        if (node.left != nil)
        {
            [stack addObject:node.left];
        }
    }
    return result;
}

@end

 2.使用队列对二叉树进行层次遍历

#import "ViewController.h"

@interface TreeNode : NSObject

@property (nonatomic, assign) NSInteger val;

@property (nonatomic, strong) TreeNode *left;

@property (nonatomic, strong) TreeNode *right;

@end

@implementation TreeNode

@end


@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
    TreeNode *root = [TreeNode new];
    root.val = 3;
    TreeNode *fLeft = [TreeNode new];
    fLeft.val = 9;
    TreeNode *fRight = [TreeNode new];
    fRight.val = 20;
    TreeNode *sLeft = [TreeNode new];
    sLeft.val = 0;
    TreeNode *sRight = [TreeNode new];
    sRight.val = 0;
    TreeNode *tLeft = [TreeNode new];
    tLeft.val = 15;
    TreeNode *tRight = [TreeNode new];
    tRight.val = 7;
    
    root.left = fLeft;
    root.right = fRight;
    
    fRight.left = tLeft;
    fRight.right = tRight;
    
    NSArray *list = [self levelOrder:root];
    NSLog(@"list = %@",list);
}


- (NSArray *)levelOrder:(TreeNode *)root
{
    NSMutableArray *result = [NSMutableArray array];
    if (root == nil) {
        return result;
    }
    //
    NSMutableArray *queue = [NSMutableArray array];
    [queue addObject:root];
    
    while (queue.count != 0)
    {
        NSMutableArray *level = [NSMutableArray array];
        int n = (int)queue.count;
        for (int i = 0 ; i < n; i++)
        {
            TreeNode *head = queue.firstObject;
            [level addObject:@(head.val)];
            if (head.left.val != 0)
            {
                [queue addObject:head.left];
            }
            
            if (head.right.val != 0)
            {
                [queue addObject:head.right];
            }
            [queue removeObjectAtIndex:0];
        }
        [result addObject:level];
    }
    return result;
}

@end

3.二叉树的中序遍历

class TreeNode
{
    public int val;
    public TreeNode left,right;
    public TreeNode(int val)
    {
        this.val = val;
        this.left = this.right = null;
    }
}

public class Main {

    public static void main(String[] args) {
    // write your code here
        TreeNode root = new TreeNode(1);
        TreeNode fLeft = new TreeNode(2);
        TreeNode fRight = new TreeNode(3);
        TreeNode sLeft  = new TreeNode(4);
        TreeNode sRight = new TreeNode(5);
        TreeNode tLeft = new TreeNode(6);
        TreeNode tRight = new TreeNode(7);
        TreeNode fourLeft = new TreeNode(8);
        TreeNode fourRight = new TreeNode(9);
        TreeNode fifthLeft = new TreeNode(10);
        TreeNode fifthRight = new TreeNode(11);
        TreeNode sixLeft = new TreeNode(12);
        TreeNode sixRight =  new TreeNode(13);

        root.left = fLeft;//2
        root.right = fRight;//3
        fLeft.left = sLeft;//4
        fLeft.right = sRight;//5
        fRight.left = tLeft;//6
        fRight.right = tRight;//7
        sLeft.left = fourLeft;//8
        sLeft.right = fourRight;//9
        sRight.left = fifthLeft;//10
        sRight.right = fifthRight;//11
        tLeft.left = sixLeft;//12
        tLeft.right = sixRight;//13

        ArrayList<Integer> list =  inorderTraversal(root);
        for (int i = 0; i < list.size(); i++) {
            System.out.printf("%d\n",list.get(i));
        }
    }
    
    public static ArrayList<Integer> inorderTraversal(TreeNode root)
    {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        ArrayList<Integer> result = new ArrayList<Integer>();
        TreeNode curt = root;
        while (curt != null || !stack.empty())
        {
            while (curt != null)
            {
                stack.add(curt);
                curt = curt.left;
            }
            curt = stack.peek();
            stack.pop();
            result.add(curt.val);
            curt = curt.right;
        }
        return result;
    }
    
}