笔记-数据结构之二叉树（iOS）

最新推荐文章于 2022-07-26 23:08:18 发布
最新推荐文章于 2022-07-26 23:08:18 发布
阅读量210 收藏
点赞数
文章标签： 数据结构与算法 c/c++
原文链接：https://juejin.im/post/5c46b19ee51d45653e3c9ae3
版权

预备知识

定义

树是一种数据结构，它是由N（N >= 1）个有限结点组成一个具有层次关系的集合。 特点：

  • 每个结点有0个或者多个子结点
  • 没有父结点的结点称为根结点
  • 每一个非根结点有且只有一个父结点
  • 除了根结点外，每个子结点可以分为多个不相交的子树

基本术语

结点n的高度： n结点到叶子结点所有路径上包含结点个数的最大值。叶子结点的高度为1，往上依次递增。
结点的深度： 从根结点到结点n唯一路径的长，根结点的深度为1（有的书上此基数为0，两种记法都没有错）
层数： 根结点为第一层，往下依次递增。
结点的度： 结点拥有的子树个数，度为0的结点称为叶子结点。
叶子： 度为零的结点。
树的度： 树中结点的最大的度。
树的高度： 树中结点的最大层次（在基数为1时，树的深度 = 树的高度 = 最大层数）。

二叉查找树

二叉查找树：

  • 若左子树不空，则左子树上所有结点的值均小于它根结点的值。
  • 若右子树不空，则右子树上所有结点的值均大于它根结点的值。
  • 左、右子树也分别为二叉查找树。
  • 没有键值相等的结点

OC语言的实现

如果想要更加透彻的理解二叉查找树相关的知识，就自己尝试的去敲一下下面的代码

定义

二叉树的实现是定义了一个工具类

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface BinaryTreeNode : NSObject
 
@property (nonatomic, assign) NSInteger keyValue;           // 值
@property (nonatomic, strong) BinaryTreeNode *leftNode;     // 左结点
@property (nonatomic, strong) BinaryTreeNode *rightNode;    // 右结点

@end

NS_ASSUME_NONNULL_END
复制代码
创建二叉查找树
/**
创建二叉排序树

@param values 数组
@return 二叉树结点
*/
+ (BinaryTreeNode *)createBinaryTreeNodeWithValues:(NSArray *)values {
    BinaryTreeNode *rootNode = nil;
    for (NSInteger i = 0; i < values.count; i ++) {
        NSInteger value = [[values objectAtIndex:i] integerValue];
        rootNode = [BinaryTreeNode addBinaryTreeNode:rootNode andValue:value];
    }
    return rootNode;
}

/**
向树结点添加结点

@param treeNode 根结点
@param value 结点值
@return 根结点
*/
+ (BinaryTreeNode *)addBinaryTreeNode:(BinaryTreeNode *)treeNode andValue:(NSInteger)value {
    if (!treeNode) {
        // 结点不存在，创建新结点
        treeNode = [[BinaryTreeNode alloc]init];
        treeNode.keyValue = value;
    }else if (value < treeNode.keyValue) {
        // 生成左子树
        treeNode.leftNode = [BinaryTreeNode addBinaryTreeNode:treeNode.leftNode andValue:value];
    }else {
        // 生成右子树
        treeNode.rightNode = [BinaryTreeNode addBinaryTreeNode:treeNode.rightNode andValue:value];
    }
    return treeNode;
}
复制代码
查找二叉树中某个位置的结点
/**
 查找二叉树某个位置的结点
 
 @param index 按层次便利树是的位置（从0开始）
 @param rootNode 树根结点
 @return 结点
 */
 + (BinaryTreeNode *)findTreeNodeAtIndex:(NSInteger)index withTree:(BinaryTreeNode *)rootNode {
    // 结点不存在，查找的位置不符合规范
    if (!rootNode || index < 0) {
        return nil;
    }
    
    NSMutableArray *queueArray = [NSMutableArray arrayWithCapacity:0];
    // 压入根结点
    [queueArray addObject:rootNode];
    while (queueArray.count > 0) {
    BinaryTreeNode *node = [queueArray firstObject];
    if (index == 0) {
         return node;
    }
    [queueArray removeObjectAtIndex:0];     // 仿照队列FIFO，t移除最前面的结点
    index--;
    
    // 按照从左到右依次压入结点
    if (node.leftNode) {
        [queueArray addObject:node.leftNode];
    }
    if (node.rightNode) {
        [queueArray addObject:node.rightNode];
    }
    }
    
    //  遍历完，还没有找到位置，返回nil
    return nil;
}
复制代码
寻找最小结点
/**
寻找最小结点

@param treeNode 树
@return 树中最小的结点
*/
+ (BinaryTreeNode *)findMinTreeNode:(BinaryTreeNode *)treeNode {
   if (!treeNode) {
       return nil;
   }
   if (!treeNode.leftNode) {
       return treeNode;
   }else {
       return [BinaryTreeNode findMinTreeNode:treeNode.leftNode];
   }
}
复制代码
先序遍历

先访问根，再遍历左子树，最后遍历右子树（递归）

/**
先序遍历
先访问根，再遍历左子树，最后遍历右子树（递归）

@param rootNode 根结点
@param handler 访问结点处理函数
*/
+ (void)preOrderTraverseBinaryTree:(BinaryTreeNode *)rootNode handle:(void(^)(BinaryTreeNode *treeNode))handler {
 if (rootNode) {
   if (handler) {
       handler(rootNode);
   }
  
  [self preOrderTraverseBinaryTree:rootNode.leftNode handle:handler];
  [self preOrderTraverseBinaryTree:rootNode.rightNode handle:handler];
 }
}
复制代码
中序遍历

先遍历左子树，再访问根，最后遍历右子树（递归）

/**
中序遍历
先遍历左子树，再访问根，最后遍历右子树（递归）

@param rootNode 根节点
@param handler 访问节点处理函数
*/
+ (void)inOrderTraverseBinaryTree:(BinaryTreeNode *)rootNode handle:(void(^)(BinaryTreeNode *treeNode))handler {
   if (rootNode) {
       [self inOrderTraverseBinaryTree:rootNode.leftNode handle:handler];
       
       if (handler) {
           handler(rootNode);
       }
       
       [self inOrderTraverseBinaryTree:rootNode.rightNode handle:handler];
   }
}
复制代码
后序遍历

先遍历左子树，再遍历右子树，最后访问根（递归）

/**
 后序遍历
 先遍历左子树，再遍历右子树，最后访问根（递归）

 @param rootNode 根节点
 @param handler 访问节点处理函数
 */
+ (void)postOrderTraverseBinaryTree:(BinaryTreeNode *)rootNode handle:(void(^)(BinaryTreeNode *treeNode))handler {
    if (rootNode) {
        [self postOrderTraverseBinaryTree:rootNode.leftNode handle:handler];
        [self postOrderTraverseBinaryTree:rootNode.rightNode handle:handler];
        
        if (handler) {
            handler(rootNode);
        }
    }
}
复制代码
层次遍历
/**
 层次遍历（广度优先）

 @param rootNode 树根节点
 @param handler 访问节点处理函数
 */
+ (void)levelTraverseBinaryTree:(BinaryTreeNode *)rootNode handle:(void(^)(BinaryTreeNode *treeNode))handler {
    if (!rootNode) {
        return;
    }
    
    NSMutableArray *queueArray = [NSMutableArray arrayWithCapacity:0];      // 数组当作队列
    [queueArray addObject:rootNode];    // 压入根节点
    
    while (queueArray.count > 0) {
        BinaryTreeNode *node = [queueArray firstObject];
        
        if (handler) {
            handler(node);
        }
        [queueArray removeObjectAtIndex:0];
        if (node.leftNode) {
            [queueArray addObject:node.leftNode];   // 压入左节点
        }
        if (node.rightNode) {
            [queueArray addObject:node.rightNode];  // 压入右节点
        }
    }
}
复制代码
二叉树的深度
/**
 二叉树的深度

 @param rootNode 根节点
 @return 二叉树的深度
 */
+ (NSInteger)depthOfBinaryTree:(BinaryTreeNode *)rootNode {
    if (!rootNode) {
        return 0;
    }
    if (!rootNode.leftNode && !rootNode.rightNode) {
        return 1;
    }
    
    // 左子树的深度
    NSInteger leftDepth = [self depthOfBinaryTree:rootNode.leftNode];
    // 右子树的深度
    NSInteger rightDepth = [self depthOfBinaryTree:rootNode.rightNode];
    
    return MAX(leftDepth, rightDepth) + 1;
}
复制代码
二叉树的宽度
/**
 二叉树的宽度

 @param rootNode 根节点
 @return 二叉树的宽度
 */
+ (NSInteger)widthOfBinaryTree:(BinaryTreeNode *)rootNode {
    if (!rootNode) {
        return 0;
    }
    
    NSMutableArray *queueArray = [NSMutableArray arrayWithCapacity:0];
    [queueArray addObject:rootNode];
    NSInteger maxWidth = 1;     // 初始化最大宽度 1
    NSInteger curWidth = 0;     // 当前层数的宽度
    
    while (queueArray.count > 0) {
        curWidth = queueArray.count;
        
        for (int i = 0; i < curWidth; i ++) {
            BinaryTreeNode *node = [queueArray firstObject];
            [queueArray removeObjectAtIndex:0];
            
            if (node.leftNode) {
                [queueArray addObject:node.leftNode];
            }
            if (node.rightNode) {
                [queueArray addObject:node.rightNode];
            }
        }
        // 宽度 = 当前层节点数
        maxWidth = MAX(maxWidth, queueArray.count);
    }
    return maxWidth;
}
复制代码
二叉树所有结点
/**
 二叉树所有节点数（递归）

 @param rootNode 根节点
 @return 所有节点数
 */
+ (NSInteger)numberOfBinaryTree:(BinaryTreeNode *)rootNode {
    if (!rootNode) {
        return 0;
    }
    
    NSInteger leftNumber = [self numberOfBinaryTree:rootNode.leftNode];
    NSInteger rightNumber = [self numberOfBinaryTree:rootNode.rightNode];
    
    // 节点数 = 左子树节点数 + 右子树节点数 + 1（根节点）
    return leftNumber + rightNumber + 1;
}
复制代码
二叉树某层的结点数
/**
 二叉树中某层中的节点数

 @param level 层数
 @param rootNode 根节点
 @return 层中的节点数
 */
+ (NSInteger)numberOfBinaryTreeNodesOnLevel:(NSInteger)level inBinaryTree:(BinaryTreeNode *)rootNode {
    if (!rootNode || level < 1) {
        return 0;
    }
    if (level == 1) {   // 根节点
        return 1;
    }
    
    // 递归：level层节点数 = 左子树level-1层节点数 + 右子树level-1层节点数
    NSInteger leftNodes = [self numberOfBinaryTreeNodesOnLevel:level - 1 inBinaryTree:rootNode.leftNode];
    NSInteger rightNodes = [self numberOfBinaryTreeNodesOnLevel:level - 1 inBinaryTree:rootNode.rightNode];
    
    return leftNodes + rightNodes;
}
复制代码
翻转二叉树
/**
 翻转二叉树（镜像）

 @param rootNode 根节点
 @return 翻转后的树的根节点（就是原二叉树的根节点）
 */
+ (BinaryTreeNode *)invertBinaryTree:(BinaryTreeNode *)rootNode {
    if (!rootNode) {
        return nil;
    }
    if (!rootNode.leftNode && !rootNode.rightNode) {
        return rootNode;
    }
    
    [self invertBinaryTree:rootNode.leftNode];
    [self invertBinaryTree:rootNode.rightNode];
    
    BinaryTreeNode *tempNode = rootNode.leftNode;
    rootNode.leftNode = rootNode.rightNode;
    rootNode.rightNode = tempNode;
    
    return rootNode;
}
复制代码
翻转二叉树（非递归）
/**
 翻转二叉树（非递归）

 @param rootNode 根结点
 @return 翻转后的二叉树
 */
+ (BinaryTreeNode *)invertBinaryTreeNotRecursive:(BinaryTreeNode *)rootNode {
    if (!rootNode) {
        return nil;
    }
    if (!rootNode.leftNode && !rootNode.rightNode) {
        return rootNode;
    }
    
    NSMutableArray *queueArray = [NSMutableArray arrayWithCapacity:0];
    [queueArray addObject:rootNode];
    
    while (queueArray.count > 0) {
        BinaryTreeNode *node = [queueArray firstObject];
        [queueArray removeObjectAtIndex:0];
        
        BinaryTreeNode *tempNode = node.leftNode;
        node.leftNode = node.rightNode;
        node.rightNode = tempNode;
        
        if (node.leftNode) {
            [queueArray addObject:node.leftNode];
        }
        if (node.rightNode) {
            [queueArray addObject:node.rightNode];
        }
    }
    return rootNode;
}
复制代码
判断是否是完全二叉树
/**
 判断是否是完全二叉树
 完全二叉树：若设二叉树的高度为h，除第h层外，其它各层的节点数都达到最大个数，第h层有叶子节点，并且叶子节点都是从左到右依次排布

 @param rootNode 根节点
 @return 是否是完全二叉树
 */
+ (BOOL)isCompleteBinaryTree:(BinaryTreeNode *)rootNode {
    if (!rootNode) {
        return NO;
    }
    if (!rootNode.leftNode && !rootNode.rightNode) {
        return YES;
    }
    if (!rootNode.leftNode && rootNode.rightNode) {
        return NO;
    }
    /**
     按层次遍历节点，找到满足完全二叉树的条件：
     条件1：如果某个节点的右子树不为空，则它的左子树必须不为空
     条件2：如果某个节点的右子树为空，则排在它后面的节点必须没有孩子节点
     排在该节点后面的节点有2种：1）同层次的后面的节点 2）同层次的前面的节点的孩子节点
     */
    NSMutableArray *queueArray = [NSMutableArray arrayWithCapacity:0];
    [queueArray addObject:rootNode];
    BOOL isComplete = NO;   // 是否是完全二叉树
    
    while (queueArray.count > 0) {
        BinaryTreeNode *node = [queueArray firstObject];
        [queueArray removeObjectAtIndex:0];
        
        // 左子树为空且右子树不为空，则不是完全二叉树
        if (!node.leftNode && node.rightNode) {
            return NO;
        }
        
        // 前面的节点已满足完全二叉树，如果还有孩子节点，则不是完全二叉树
        if (isComplete && (node.leftNode || node.rightNode)) {
            return NO;
        }
        
        // 右子树为空，则已满足完全二叉树
        if (!node.rightNode) {
            isComplete = YES;
        }
        
        if (node.leftNode) {
            [queueArray addObject:node.leftNode];
        }
        if (node.rightNode) {
            [queueArray addObject:node.rightNode];
        }
    }
    return isComplete;
}
复制代码
判断是否是满二叉树
/**
 是否是满二叉树
 满二叉树：除了叶节点外每一个节点都有左右子叶且叶节点都处在最底层的二叉树

 @param rootNode 根节点
 @return 是否是满二叉树
 */
+ (BOOL)isFullBinaryTree:(BinaryTreeNode *)rootNode {
    if (!rootNode) {
        return NO;
    }
    
    // 深度
    NSInteger depth = [self depthOfBinaryTree:rootNode];
    // 二叉树叶子节点数
    NSInteger leafNum = [self numberOfBinaryTree:rootNode];
    
    // 是否满足：叶子树 = 2^(深度 - 1)
    if (leafNum == pow(2, depth - 1)) {
        return YES;
    }
    return NO;
}
复制代码
判断是否是平衡树（AVL树）
/**
 是否是AVL树（平衡二叉树）
 AVL树：是一颗空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一颗平衡二叉树
 @param rootNode 根节点
 @return 是否是AVL树
 */
+ (BOOL)isAVLBinaryTree:(BinaryTreeNode *)rootNode {
    //static修饰局部变量时，在程序中只有一份内存，并延长其生命周期
    static NSInteger height;
    if (!rootNode) {
        height = 0;
        return YES;
    }
    if (!rootNode.leftNode && !rootNode.rightNode) {
        height = 1;
        return YES;
    }
    
    // 左子树是否是AVL树
    BOOL isAVLLeftTree = [self isAVLBinaryTree:rootNode.leftNode];
    NSInteger heightLeft = height;
    // 右子树是否是AVL树
    BOOL isAVLRightTree = [self isAVLBinaryTree:rootNode.rightNode];
    NSInteger heightRight = height;
    
    height = MAX(heightLeft, heightRight) + 1;
    
    // 左右两颗子树的高度差的绝对值不超过1且两个子树都是AVL树
    if (isAVLLeftTree && isAVLRightTree && ABS(heightLeft - heightRight) <= 1) {
        return YES;
    }
    return NO;
}
复制代码

更多相关资料：
二叉查找树之图文解析和C语言的实现
AVL树之图文解析和C语言的实现

参考网上资料：
二叉树-你必须要懂！
二叉树的各种问题

weixin_33704591
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
iOS实现反转二叉树（前序遍历二叉树）
Z1591090的博客
12-25 2705
题目: Input: Output: 首先分析下这个二叉树,从上往下看发现这个树是把树上的数据进行了交换,但是仔细一看发现最后一排的1-3反转过去后变成了3-1.所以得出结论,这道题是左右子树进行了交换,用函数递归就能很容易实现了. OC版本 声明节点属性： #import <Foundation/Foundation.h> NS_ASSUME_NONNULL_BEGIN @i...
《数据结构与算法之美》21～25笔记
KevinAshen的博客
10-31 753
文章目录关于我的仓库前言21讲哈希算法（上）：如何防止数据库中的用户信息被脱库哈希算法MD5初识哈希算法七应用【前四】应用一：安全加密应用二：唯一标识应用三：数据校验应用四：散列函数解答开篇：守护最好的用户数据库课后题：现在，区块链是一个很火的领域，它被很多人神秘化，不过其底层的实现原理并不复杂。其中，哈希算法就是它的一个非常重要的理论基础。你能讲一讲区块链使用的是哪种哈希算法吗？是为了解决什么问...
iOS二叉树
SuYuMingXiangGuan的博客
12-23 1613
#import @interface BinaryTreeNode : NSObject ///值 @property (nonatomic, assign) NSInteger value; ///左节点 @property (nonatomic, strong) BinaryTreeNode *leftNode; ///右节点 @property (nonatomic, strong)
iOS实现二叉树数据结构
ff_wwb的专栏
08-04 876
#头文件 @interface YFTree : NSObject /**  根节点的值  */ @property (nonatomic, strong) ObjectType rootData; @property (nonatomic, strong) YFTree *leftTree; @property (nonatomic, strong)
iOS数据结构与算法实战 二叉树总结篇
weixin_33994429的博客
05-13 474
树的基本概念篇 前言 由于我们后面讲的一些结构有很多是树结构实现的比如堆，然后基于堆可以实现优先级队列，有界优先级队列等，所以我们先讲述树结构，我们可能常见到的是二叉树，但是还有一些其他的树的概念：比如二叉搜索树，AVL树，红黑树，B树，决策树等。以便于在特定场景下使用。 树的一些应用场景 CFBinaryHeap 这个类在iOS中你可能会见到，这是一个二叉搜索算法实现的一个二叉堆，后面的pri...
【iOS】二叉树的各种问题（OC代码）
哔哔哔的专栏
08-07 651
昨天学习了一下算法，找了几个例子，总结到一个demo里面。什么是二叉树？二叉树算法主要是递归的思想，维基百科上对递归的定义：在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。我理解的话就是好像一个包子馅的包子，然后包子里面还是包子馅，一直循环下去，最后找到出口就是包子里面是个馒头。在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”和“右子树”，左子
算法：《数据结构与算法之美》学习笔记以及Swift代码实现，原始仓库https：github.comwangzheng0822algo
02-01
《数据结构与算法之美》是一本深入探讨编程基础——数据结构和算法的书籍。通过学习这本书，开发者可以提升解决问题的能力，提高代码效率，并为解决复杂问题打下坚实的基础。这份学习笔记结合了Swift语言，提供了...
数据结构与算法(AcWing)，持续更新中
JJJYY2的博客
07-26 539
AcWing算法学习笔记，学习使用，仅供参考，如有错误，欢迎探讨。
黑马程序员----c基础笔记----指针
gaopanmdj的博客
09-05 340
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 1、地址概念的理解：              计算机硬件系统的内部存储器中，拥有大量的存储单元(容量为1字节)。为了方便管理，必须为每个存储单元编号，这个编号就是存储单元的“地址”。每个存储都有一个唯一的地址。                       内存地址———内存单元的编号
腾讯控股研发工程师笔试真题三-教程与笔记习题
05-18
1. 数据结构与算法： - 字符串匹配算法：在笔试中可能会涉及到KMP、Boyer-Moore或Rabin-Karp等字符串查找算法，这些算法对于处理文本数据至关重要。 - 排序算法：快速排序、归并排序、堆排序等，理解和应用它们能...
二叉树遍历 数据结构
06-13
C++6.0实验通过 #define EL 10 #define TEL 2*EL+1 #define LEN sizeof(struct node) #include<stdio.h> #include<stdlib.h> #include<iostream> using namespace std;
【数据结构】【iOS】二叉树的遍历
huangruiz1的博客
10-19 605
二叉树的遍历方式有三种 1、前序遍历NLR（Preorder Traversal，先序遍历 2、中序遍历LNR（Inorder Traversal） 3、后序遍历LRN（Postorder Traversal） 代码 Swift class TreeNode { var val: Int var left: TreeNode? var right: TreeNode? init(_ val: Int) { self.val = val self
iOS开发算法--二叉树
MinggeQingchun的博客
05-23 1459
二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆(详见堆排序)。二叉树不是树的一种特殊情形，尽管其与树有许多相似之处，但树和二 叉树有两个主要差别：树中结点的最大度数没有限制，而二叉树结点的最大度数为2； 树的结点无左、右之分，而二叉树的结点有左、右之分。 详细代码请参考A
257. 二叉树的所有路径
Finish_Hou
07-31 64
257. 二叉树的所有路径 难度：简单 给定一个二叉树，返回所有从根节点到叶子节点的路径。 说明: 叶子节点是指没有子节点的节点。 示例: 输入: 1 / \ 2 3 \ 5 输出: ["1->2->5", "1->3"] 解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3 解答： /** * Definition for a binary tree node. * public class TreeNode { *
iOS LeetCode ☞ 二叉树的前序遍历
HumorousGhost
06-18 247
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。 示例 1： 输入：root = [1,null,2,3] 输出：[1,2,3] 示例 2： 输入：root = [] 输出：[] 示例 3： 输入：root = [1] 输出：[1] 示例 4： 输入：root = [1,2] 输出：[1,2] 示例 5： 输入：root = [1,null,2] 输出：[1,2] 提示： 树中节点数目在范围 [0, 100] 内 -100 <= Node.val <= 100 进
iOS 算法面试题(字符串逆序输出、二叉树、归并排序)~demo
石虎
08-13 2687
//联系人:石虎  QQ: 1224614774昵称:嗡嘛呢叭咪哄 一、字符串逆序输出 1、实现一个字符串“how are you”的逆序输出（编程语言不限）。如给定字符串为“hello world”,输出结果应当为“world hello”。     [cpp] view plain copy     int spliterFu
LeetCode 124 二叉树中的最大路径和 NC6 二叉树中的最大路径和
麦格芬230的博客
01-11 114
给定一个非空二叉树，返回其最大路径和。 本题中，路径被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。 示例 1： 输入：[1,2,3] 1 / \ 2 3 输出：6 示例2： 输入：[-10,9,20,null,null,15,7] -10 / \ 9 20 / \ 15 7 输出：42 Python代码： # Def......
iOS LeetCode ☞ 从中序与后序遍历序列构造二叉树
HumorousGhost
05-31 143
根据一棵树的中序遍历与后序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如，给出 中序遍历 inorder = [9,3,15,20,7] 后序遍历 postorder = [9,15,7,20,3] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 解题思路 思路 首先解决这道题我们需要明确给定一棵二叉树，我们是如何对其进行中序遍历与后序遍历的： 中序遍历的顺序是每次遍历左孩子，再遍历根节点，最后遍历右孩子。 后序遍历的顺序是每次遍历左
iOS高级程序员进阶——基础算法篇
10-27
算法通常是指解决问题的方案和步骤，在编程中，更通俗的讲算法就是解决特定问题的一系列指令。算法要求对于一定规模内的输入，在有限时间内会获得所要求的输出。通常，一个算法的优劣由时间复杂度和空间复杂度来衡量。作为iOS开发者我们是否需要学习算法，毋庸置疑是需要的。就算是非常面向业务的开发需求，有算法基础的开发者也会编写出更加优质的代码，在输入规模扩大的情况下，这些优质的代码也会拥有更强的稳定性并使得应用程序表现出更好的性能。在笔试面试中，算法大多情况下也是必考部分。熟悉常用的基础算法是开发者的基本功。除了提高代码质量与面试加分外，学习算法也可以锻炼思维能力，提高开发者的逻辑思维能力与抽象建模能力。在技术迭代发展飞快的当今，掌握核心算法要比掌握一门应用技术更加重要。
森林转二叉树算法解析-数据结构
"这篇资料主要介绍了森林转换为二叉树的方法，特别是‘兄弟相连，长兄为父’的策略，并涉及数据结构中的二叉树存储结构，包括顺序存储和链式存储。" 在数据结构中，二叉树是一种重要的非线性数据结构，它由若干个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值