关于二叉树的算法相关

最新推荐文章于 2023-05-25 09:00:00 发布
最新推荐文章于 2023-05-25 09:00:00 发布
阅读量121 收藏
点赞数
文章标签： 数据结构与算法 面试 移动开发
原文链接：http://www.cnblogs.com/seth-chen/p/5206206.html
版权

这几天详细了解了下二叉树的相关算法，原因是看了唐boy的一篇博客（ 你会翻转二叉树吗？ ），还有一篇关于 百度的校园招聘面试经历 ，深刻体会到二叉树的重要性。于是乎，从网上收集并整理了一些关于二叉树的资料，及相关算法的实现（主要是Objective-C的，但是算法思想是相通的），以便以后复习时查阅。

什么是二叉树？

在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”和“右子树”，左子树和右子树同时也是二叉树。二叉树的子树有左右之分，并且次序不能任意颠倒。二叉树是递归定义的，所以一般二叉树的相关题目也都可以使用递归的思想来解决，当然也有一些可以使用非递归的思想解决，我下面列出的一些算法有些采用了递归，有些是非递归的。

什么是二叉排序树？

二叉排序树又叫二叉查找树或者二叉搜索树，它首先是一个二叉树，而且必须满足下面的条件：

1）若左子树不空，则左子树上所有结点的值均小于它的根节点的值；

2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值

3）左、右子树也分别为二叉排序树

4）没有键值相等的节点（？可能是因为不好处理键值相等的节点到底是左节点还是右节点吧）

概念就介绍这么多，都是来自网上，下面主要看算法和具体实现代码。

二叉树节点定义

采用单项链表的形式，只从根节点指向孩子节点，不保存父节点。

/**
 *  二叉树节点
 */
@interface BinaryTreeNode : NSObject

/**
 *  值
 */
@property (nonatomic, assign) NSInteger value;
/** * 左节点 */ @property (nonatomic, strong) BinaryTreeNode *leftNode; /** * 右节点 */ @property (nonatomic, strong) BinaryTreeNode *rightNode; @end

创建二叉排序树

二叉树中左右节点值本身没有大小之分，所以如果要创建二叉树，就需要考虑如何处理某个节点是左节点还是右节点，如何终止某个子树而切换到另一个子树。 因此我选择了二叉排序树，二叉排序树中对于左右节点有明确的要求，程序可以自动根据键值大小自动选择是左节点还是右节点。

/**
 *  创建二叉排序树
 *  二叉排序树：左节点值全部小于根节点值，右节点值全部大于根节点值
 *
 *  @param values 数组
 *
 *  @return 二叉树根节点
 */
+ (BinaryTreeNode *)createTreeWithValues:(NSArray *)values {
  BinaryTreeNode *root = nil;
 for (NSInteger i=0; i<values.count; i++) {   NSInteger value = [(NSNumber *)[values objectAtIndex:i] integerValue];   root = [BinaryTree addTreeNode:root value:value];  }  return root; } /** * 向二叉排序树节点添加一个节点 * * @param treeNode 根节点 * @param value 值 * * @return 根节点 */ + (BinaryTreeNode *)addTreeNode:(BinaryTreeNode *)treeNode value:(NSInteger)value {  //根节点不存在，创建节点  if (!treeNode) {   treeNode = [BinaryTreeNode new];   treeNode.value = value;   NSLog(@"node:%@", @(value));  }  else if (value <= treeNode.value) {   NSLog(@"to left");   //值小于根节点，则插入到左子树   treeNode.leftNode = [BinaryTree addTreeNode:treeNode.leftNode value:value];  }  else {   NSLog(@"to right");   //值大于根节点，则插入到右子树   treeNode.rightNode = [BinaryTree addTreeNode:treeNode.rightNode value:value];  }  return treeNode; }

二叉树中某个位置的节点

类似索引操作，按层次遍历，位置从0开始算。

/**
 *  二叉树中某个位置的节点（按层次遍历）
 *
 *  @param index	按层次遍历树时的位置(从0开始算)
 *  @param rootNode 树根节点
 *
 *  @return 节点
 */
+ (BinaryTreeNode *)treeNodeAtIndex:(NSInteger)index inTree:(BinaryTreeNode *)rootNode {
 //按层次遍历  if (!rootNode || index < 0) {   return nil;  }  NSMutableArray *queueArray = [NSMutableArray array]; //数组当成队列  [queueArray addObject:rootNode]; //压入根节点  while (queueArray.count > 0) {   BinaryTreeNode *node = [queueArray firstObject];   if (index == 0) {    return node;   }   [queueArray removeObjectAtIndex:0]; //弹出最前面的节点，仿照队列先进先出原则   index--; //移除节点，index减少   if (node.leftNode) {    [queueArray addObject:node.leftNode]; //压入左节点   }   if (node.rightNode) {    [queueArray addObject:node.rightNode]; //压入右节点   }  }  //层次遍历完，仍然没有找到位置，返回nil  return nil; }

先序遍历

先访问根，再遍历左子树，再遍历右子树。典型的递归思想。

/**
 *  先序遍历
 *  先访问根，再遍历左子树，再遍历右子树
 *
 *  @param rootNode 根节点
 *  @param handler  访问节点处理函数
 */
+ (void)preOrderTraverseTree:(BinaryTreeNode *)rootNode handler:(void(^)(BinaryTreeNode *treeNode))handler {  if (rootNode) {   if (handler) {    handler(rootNode);   }   [self preOrderTraverseTree:rootNode.leftNode handler:handler];   [self preOrderTraverseTree:rootNode.rightNode handler:handler];  } }

调用方法如下：（用到了block）

NSMutableArray *orderArray = [NSMutableArray array];
[BinaryTree preOrderTraverseTree:root handler:^(BinaryTreeNode *treeNode) {
     [orderArray addObject:@(treeNode.value)];
}];
NSLog(@"先序遍历结果：%@", [orderArray componentsJoinedByString:@","]);

中序遍历

先遍历左子树，再访问根，再遍历右子树。

对于二叉排序树来说，中序遍历得到的序列是一个从小到大排序好的序列。

/**
 *  中序遍历
 *  先遍历左子树，再访问根，再遍历右子树
 *
 *  @param rootNode 根节点
 *  @param handler  访问节点处理函数
 */
+ (void)inOrderTraverseTree:(BinaryTreeNode *)rootNode handler:(void(^)(BinaryTreeNode *treeNode))handler {  if (rootNode) {   [self inOrderTraverseTree:rootNode.leftNode handler:handler];   if (handler) {    handler(rootNode);   }   [self inOrderTraverseTree:rootNode.rightNode handler:handler];  } }

后序遍历

先遍历左子树，再遍历右子树，再访问根

/**
 *  后序遍历
 *  先遍历左子树，再遍历右子树，再访问根
 *
 *  @param rootNode 根节点
 *  @param handler  访问节点处理函数
 */
+ (void)postOrderTraverseTree:(BinaryTreeNode *)rootNode handler:(void(^)(BinaryTreeNode *treeNode))handler {  if (rootNode) {   [self postOrderTraverseTree:rootNode.leftNode handler:handler];   [self postOrderTraverseTree:rootNode.rightNode handler:handler];   if (handler) {    handler(rootNode);   }  } }

层次遍历

按照从上到下、从左到右的次序进行遍历。先遍历完一层，再遍历下一层，因此又叫广度优先遍历。需要用到队列，在OC里可以用可变数组来实现。

/**
 *  层次遍历（广度优先）
 *
 *  @param rootNode 二叉树根节点
 *  @param handler  访问节点处理函数
 */
+ (void)levelTraverseTree:(BinaryTreeNode *)rootNode handler:(void(^)(BinaryTreeNode *treeNode))handler {  if (!rootNode) {   return;  }  NSMutableArray *queueArray = [NSMutableArray array]; //数组当成队列  [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]; //压入右节点   }  } }

二叉树的深度

二叉树的深度定义为：从根节点到叶子结点依次经过的结点形成树的一条路径,最长路径的长度为树的深度。

1）如果根节点为空，则深度为0；

2）如果左右节点都是空，则深度为1；

3）递归思想：二叉树的深度=max（左子树的深度，右子树的深度）+ 1

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

二叉树的宽度

二叉树的宽度定义为各层节点数的最大值。

/**
 *  二叉树的宽度
 *
 *  @param rootNode 二叉树根节点
 *
 *  @return 二叉树宽度
 */
+ (NSInteger)widthOfTree:(BinaryTreeNode *)rootNode {
  if (!rootNode) {   return 0;  }  NSMutableArray *queueArray = [NSMutableArray array]; //数组当成队列  [queueArray addObject:rootNode]; //压入根节点  NSInteger maxWidth = 1; //最大的宽度，初始化为1（因为已经有根节点）  NSInteger curWidth = 0; //当前层的宽度  while (queueArray.count > 0) {   curWidth = queueArray.count;   //依次弹出当前层的节点   for (NSInteger 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; }

二叉树的所有节点数

递归思想：二叉树所有节点数=左子树节点数+右子树节点数+1

/**
 *  二叉树的所有节点数
 *
 *  @param rootNode 根节点
 *
 *  @return 所有节点数
 */
+ (NSInteger)numberOfNodesInTree:(BinaryTreeNode *)rootNode {
    if (!rootNode) {
        return 0; } //节点数=左子树节点数+右子树节点数+1（根节点） return [self numberOfNodesInTree:rootNode.leftNode] + [self numberOfNodesInTree:rootNode.rightNode] + 1; }

二叉树某层中的节点数

1）根节点为空，则节点数为0；

2）层为1，则节点数为1（即根节点）

3）递归思想：二叉树第k层节点数=左子树第k-1层节点数+右子树第k-1层节点数

/**
 *  二叉树某层中的节点数
 *
 *  @param level    层
 *  @param rootNode 根节点
 *
 *  @return 层中的节点数
 */
+ (NSInteger)numberOfNodesOnLevel:(NSInteger)level inTree:(BinaryTreeNode *)rootNode {
    if (!rootNode || level < 1) { //根节点不存在或者level<0 return 0; } if (level == 1) { //level=1，返回1（根节点） return 1; } //递归：level层节点数 = 左子树level-1层节点数+右子树level-1层节点数 return [self numberOfNodesOnLevel:level-1 inTree:rootNode.leftNode] + [self numberOfNodesOnLevel:level-1 inTree:rootNode.rightNode]; }

二叉树叶子节点数

叶子节点，又叫终端节点，是左右子树都是空的节点。

/**
 *  二叉树叶子节点数
 *
 *  @param rootNode 根节点
 *
 *  @return 叶子节点数
 */
+ (NSInteger)numberOfLeafsInTree:(BinaryTreeNode *)rootNode {
  if (!rootNode) {   return 0;  }  //左子树和右子树都是空，说明是叶子节点  if (!rootNode.leftNode && !rootNode.rightNode) {   return 1;  }  //递归：叶子数 = 左子树叶子数 + 右子树叶子数  return [self numberOfLeafsInTree:rootNode.leftNode] + [self numberOfLeafsInTree:rootNode.rightNode]; }

二叉树最大距离（二叉树的直径）

二叉树中任意两个节点都有且仅有一条路径，这个路径的长度叫这两个节点的距离。二叉树中所有节点之间的距离的最大值就是二叉树的直径。

有一种解法，把这个最大距离划分了3种情况：

1）这2个节点分别在根节点的左子树和右子树上，他们之间的路径肯定经过根节点，而且他们肯定是根节点左右子树上最远的叶子节点（他们到根节点的距离=左右子树的深度）。

2）这2个节点都在左子树上

3）这2个节点都在右子树上

综上，只要取这3种情况中的最大值，就是二叉树的直径。

/**
 *  二叉树最大距离（直径）
 *
 *  @param rootNode 根节点
 *
 *  @return 最大距离
 */
+ (NSInteger)maxDistanceOfTree:(BinaryTreeNode *)rootNode {
  if (!rootNode) {   return 0;  } // 方案一：（递归次数较多，效率较低）  //分3种情况：  //1、最远距离经过根节点：距离 = 左子树深度 + 右子树深度  NSInteger distance = [self depthOfTree:rootNode.leftNode] + [self depthOfTree:rootNode.rightNode];  //2、最远距离在根节点左子树上，即计算左子树最远距离  NSInteger disLeft = [self maxDistanceOfTree:rootNode.leftNode];  //3、最远距离在根节点右子树上，即计算右子树最远距离  NSInteger disRight = [self maxDistanceOfTree:rootNode.rightNode];  return MAX(MAX(disLeft, disRight), distance); }

这个方案效率较低，因为计算子树的深度和最远距离是分开递归的，存在重复递归遍历的情况。其实一次递归，就可以分别计算出深度和最远距离，于是有了第二种方案：

/**
 *  二叉树最大距离（直径）
 *
 *  @param rootNode 根节点
 *
 *  @return 最大距离
 */
+ (NSInteger)maxDistanceOfTree:(BinaryTreeNode *)rootNode {
  if (!rootNode) {   return 0;  } // 方案2：将计算节点深度和最大距离放到一次递归中计算，方案一是分别单独递归计算深度和最远距离  TreeNodeProperty *p = [self propertyOfTreeNode:rootNode];  return p.distance; } /** * 计算树节点的最大深度和最大距离 * * @param rootNode 根节点 * * @return TreeNodeProperty */ + (TreeNodeProperty *)propertyOfTreeNode:(BinaryTreeNode *)rootNode {  if (!rootNode) {   return nil;  }  TreeNodeProperty *left = [self propertyOfTreeNode:rootNode.leftNode];  TreeNodeProperty *right = [self propertyOfTreeNode:rootNode.rightNode];  TreeNodeProperty *p = [TreeNodeProperty new];  //节点的深度depth = 左子树深度、右子树深度中最大值+1（+1是因为根节点占了1个depth）  p.depth = MAX(left.depth, right.depth) + 1;  //最远距离 = 左子树最远距离、右子树最远距离和横跨左右子树最远距离中最大值  p.distance = MAX(MAX(left.distance, right.distance), left.depth+right.depth);  return p; }

二叉树中某个节点到根节点的路径

既是寻路问题，又是查找节点问题。

定义一个存放路径的栈（不是队列了，但是还是用可变数组来实现的）

1）压入根节点，再从左子树中查找（递归进行的），如果未找到，再从右子树中查找，如果也未找到，则弹出根节点，再遍历栈中上一个节点。

2）如果找到，则栈中存放的节点就是路径所经过的节点。

/**
 *  二叉树中某个节点到根节点的路径
 *
 *  @param treeNode 节点
 *  @param rootNode 根节点
 *
 *  @return 存放路径节点的数组
 */
+ (NSArray *)pathOfTreeNode:(BinaryTreeNode *)treeNode inTree:(BinaryTreeNode *)rootNode {
 NSMutableArray *pathArray = [NSMutableArray array];  [self isFoundTreeNode:treeNode inTree:rootNode routePath:pathArray];  return pathArray; } /** * 查找某个节点是否在树中 * * @param treeNode 待查找的节点 * @param rootNode 根节点 * @param path 根节点到待查找节点的路径 * * @return YES：找到，NO：未找到 */ + (BOOL)isFoundTreeNode:(BinaryTreeNode *)treeNode inTree:(BinaryTreeNode *)rootNode routePath:(NSMutableArray *)path {  if (!rootNode || !treeNode) {   return NO;  }  //找到节点  if (rootNode == treeNode) {   [path addObject:rootNode];   return YES;  }  //压入根节点，进行递归  [path addObject:rootNode];  //先从左子树中查找  BOOL find = [self isFoundTreeNode:treeNode inTree:rootNode.leftNode routePath:path];  //未找到，再从右子树查找  if (!find) {   find = [self isFoundTreeNode:treeNode inTree:rootNode.rightNode routePath:path];  }  //如果2边都没查找到，则弹出此根节点  if (!find) {   [path removeLastObject];  }  return find; }

二叉树中两个节点最近的公共父节点

首先需要明白，根节点肯定是二叉树中任意两个节点的公共父节点（不一定是最近的），因此二叉树中2个节点的最近公共父节点一定在从根节点到这个节点的路径上。因此我们可以先分别找到从根节点到这2个节点的路径，再从这两个路径中找到最近的公共父节点。

/**
 *  二叉树中两个节点最近的公共父节点
 *
 *  @param nodeA	第一个节点
 *  @param nodeB	第二个节点
 *  @param rootNode 二叉树根节点
 *
 *  @return 最近的公共父节点 */ + (BinaryTreeNode *)parentOfNode:(BinaryTreeNode *)nodeA andNode:(BinaryTreeNode *)nodeB inTree:(BinaryTreeNode *)rootNode {  if (!rootNode || !nodeA || !nodeB) {   return nil;  }  if (nodeA == nodeB) {   return nodeA;  }  //从根节点到节点A的路径  NSArray *pathA = [self pathOfTreeNode:nodeA inTree:rootNode];  //从根节点到节点B的路径  NSArray *pathB = [self pathOfTreeNode:nodeB inTree:rootNode];  //其中一个节点不在树中，则没有公共父节点  if (pathA.count == 0 || pathB == 0) {   return nil;  }  //从后往前推，查找第一个出现的公共节点  for (NSInteger i = pathA.count-1; i>=0; i--) {   for (NSInteger j = pathB.count - 1; j>=0; j--) {    if ([pathA objectAtIndex:i] == [pathB objectAtIndex:j]) {     //找到     return [pathA objectAtIndex:i];    }   }  }  return nil; }

二叉树中两个节点之间的路径

从查找最近公共父节点衍生出来的。

/**
 *  二叉树中两个节点之间的路径
 *
 *  @param nodeA	第一个节点
 *  @param nodeB	第二个节点
 *  @param rootNode 二叉树根节点
 *
 *  @return 两个节点间的路径 */ + (NSArray *)pathFromNode:(BinaryTreeNode *)nodeA toNode:(BinaryTreeNode *)nodeB inTree:(BinaryTreeNode *)rootNode {  if (!rootNode || !nodeA || !nodeB) {   return nil;  }  NSMutableArray *path = [NSMutableArray array];  if (nodeA == nodeB) {   [path addObject:nodeA];   [path addObject:nodeB];   return path;  }  //从根节点到节点A的路径  NSArray *pathA = [self pathOfTreeNode:nodeA inTree:rootNode];  //从根节点到节点B的路径  NSArray *pathB = [self pathOfTreeNode:nodeB inTree:rootNode];  //其中一个节点不在树中，则没有路径  if (pathA.count == 0 || pathB == 0) {   return nil;  }  //从后往前推，查找第一个出现的公共节点  for (NSInteger i = pathA.count-1; i>=0; i--) {   [path addObject:[pathA objectAtIndex:i]];   for (NSInteger j = pathB.count - 1; j>=0; j--) {    //找到公共父节点，则将pathB中后面的节点压入path    if ([pathA objectAtIndex:i] == [pathB objectAtIndex:j]) {     j++; //j++是为了避开公共父节点     while (j<pathB.count) {      [path addObject:[pathB objectAtIndex:j]];      j++;     }     return path;    }   }  }  return nil; }

二叉树两个节点之间的距离

可以从两个节点之间的路径衍生出来。

/**
 *  二叉树两个节点之间的距离
 *
 *  @param nodeA	第一个节点
 *  @param nodeB	第二个节点
 *  @param rootNode 二叉树根节点
 *
 *  @return 两个节点间的距离（-1：表示没有找到路径） */ + (NSInteger)distanceFromNode:(BinaryTreeNode *)nodeA toNode:(BinaryTreeNode *)nodeB inTree:(BinaryTreeNode *)rootNode {  if (!rootNode || !nodeA || !nodeB) {   return -1;  }  if (nodeA == nodeB) {   return 0;  }  //从根节点到节点A的路径  NSArray *pathA = [self pathOfTreeNode:nodeA inTree:rootNode];  //从根节点到节点B的路径  NSArray *pathB = [self pathOfTreeNode:nodeB inTree:rootNode];  //其中一个节点不在树中，则没有路径  if (pathA.count == 0 || pathB == 0) {   return -1;  }  //从后往前推，查找第一个出现的公共节点  for (NSInteger i = pathA.count-1; i>=0; i--) {   for (NSInteger j = pathB.count - 1; j>=0; j--) {    //找到公共父节点    if ([pathA objectAtIndex:i] == [pathB objectAtIndex:j]) {     //距离=路径节点数-1 （这里要-2，因为公共父节点重复了一次）     return (pathA.count - i) + (pathB.count - j) - 2;    }   }  }  return -1; }

翻转二叉树

你会翻转二叉树吗？如果不会，那对不起，我们不会录用你！

翻转二叉树，又叫求二叉树的镜像，就是把二叉树的左右子树对调（当然是递归的）

/**
 *  翻转二叉树（又叫：二叉树的镜像）
 *
 *  @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; }

判断二叉树 是否完全二叉树

完全二叉树定义为： 若设二叉树的高度为 h ，除第 h 层外，其它各层的结点数都达到最大个数，第 h 层有叶子结点，并且叶子结点都是从左到右依次排布。

完全二叉树必须满足2个条件：

1） 如果某个节点的右子树不为空，则它的左子树必须不为空

2） 如果某个节点的右子树为空，则排在它后面的节点必须没有孩子节点

这里还需要理解“排在它后面的节点”，回头看看层次遍历算法，我们就能知道在层次遍历时，是从上到下从左到右遍历的，先将根节点弹出队列，再压入孩子节点，因此“排在它后面的节点”有2种情况：

1） 同层次的后面的节点

2） 同层次的前面的节点的孩子节点（因为遍历前面的节点时，会弹出节点，同时将孩子节点压入队列）

通过上面的分析，我们可以设置一个标志位flag，当子树满足完全二叉树时，设置flag=YES。当flag=YES而节点又破坏了完全二叉树的条件，那么它就不是完全二叉树。

/**
 *  是否完全二叉树
 *  完全二叉树：若设二叉树的高度为h，除第h层外，其它各层的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布
 *
 *  @param rootNode 根节点
 *
 *  @return YES：是完全二叉树，NO：不是完全二叉树
 */
+ (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）同层次的前面的节点的孩子节点（因为遍历前面的节点的时候，会将节点从队列里pop，同时把它的孩子节点push到队列里）  NSMutableArray *queue = [NSMutableArray array];  [queue addObject:rootNode];  BOOL isComplete = NO; //是否已经满足完全二叉树  while (queue.count > 0) {   BinaryTreeNode *node = [queue firstObject];   [queue 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) {    [queue addObject:node.leftNode];   }   if (node.rightNode) {    [queue addObject:node.rightNode];   }  }  return isComplete; }

判断二叉树是否满二叉树

满二叉树定义为： 除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树

满二叉树的一个特性是：叶子数=2^(深度-1)，因此我们可以根据这个特性来判断二叉树是否是满二叉树。

/**
 *  是否满二叉树
 *  满二叉树：除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树
 *
 *  @param rootNode 根节点
 *
 *  @return YES：满二叉树，NO：非满二叉树
 */
+ (BOOL)isFullBinaryTree:(BinaryTreeNode *)rootNode {
  if (!rootNode) {   return NO;  }  //二叉树深度  NSInteger depth = [self depthOfTree:rootNode];  //二叉树叶子节点数  NSInteger leafNum = [self numberOfLeafsInTree:rootNode];  //满二叉树特性：叶子数=2^(深度-1)  if (leafNum == pow(2, (depth - 1))) {   return YES;  }  return NO; }

判断二叉树是否平衡二叉树

平衡二叉树定义为： 它是一棵空树或它的左右两个子树的高度差的绝对值不超过 1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树又叫AVL树。

/**
 *  是否平衡二叉树
 *  平衡二叉树：即AVL树，它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树
 *
 *  @param rootNode 根节点
 *
 *  @return YES：平衡二叉树，NO：非平衡二叉树
 */
+ (BOOL)isAVLBinaryTree:(BinaryTreeNode *)rootNode {
  static NSInteger height;  if (!rootNode) {   height = 0;   return YES;  }  if (!rootNode.leftNode && !rootNode.rightNode) {   height = 1;   return YES;  }  BOOL isAVLLeft = [self isAVLBinaryTree:rootNode.leftNode];  NSInteger heightLeft = height;  BOOL isAVLRight = [self isAVLBinaryTree:rootNode.rightNode];  NSInteger heightRight = height;  height = MAX(heightLeft, heightRight)+1;  if (isAVLLeft && isAVLRight && ABS(heightLeft-heightRight) <= 1) {   return YES;  }  return NO; }

总结

以上就是我目前整理的一些二叉树相关的算法，算法资料和思想都来源于网络，如有错误，欢迎指正！后续如果有新的算法，我也会更新进去。

转载于:https://www.cnblogs.com/seth-chen/p/5206206.html

anminghui6493
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
关于二叉树的典型算法实现
12-22
二叉树的典型算法实现
总结----20个最常见的算法面试问题
Gassuih的博客
03-16 2万+
在互联网面试的过程中，有一个环节是逃不掉的，就是算法面试。一般，面试官出的面试题都是从题库里抽出来的，很少有自己出新题的（当然，算法笔试过程除外）。所以，只要我们刷题刷的足够多，就总有概率遇到原题。当然，我们也可以押题，毕竟，一些高频率的题目总是有代表性的。 本文列举了20个在计算机面试过程中经常被问到的算法题，排名不分前后，这些题目也只是代表我自己在面试过程中的体会，所以有些好题目没有加入进来也请轻喷，仅供参考。 方法 前缀和 双指针法 滑动窗口 广度、深度优先搜索 回溯法 二分法 动态规划 20个常
面试常用算法归纳
上官宏竹的专栏
11-17 2698
注意：这里需要使用一个pair记录前一个dp[i]的最长子串的始末位置，在判断s[i]与s[i-1]不等时，需要继续往前判断s[i]是否包含在前一个dp[i-1]的子串中，如果在，则当前的dp[i]需要减去dp[i-1]子串的前一部分。对于二维dp的状态转移方程，大致都会是要从左、上及左上三个方向来推导，即：dp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])。对于dp[i]的定义为：以s[i]为结尾的【无重复字符的最长子串】的长度。
算法面试题汇总
学Java，找哪吒
08-23 1万+
大家好，我是哪吒，一个热爱编码的Java工程师，本着“欲速则不达，欲达则欲速”的学习态度，在程序猿这条不归路上不断成长，所谓成长，不过是用时间慢慢擦亮你的眼睛，少时看重的，年长后却视若鸿毛，少时看轻的，年长后却视若泰山，成长之路，亦是渐渐放下执念，内心归于平静的旅程。 也许，我们永远都不会知道自己能走到何方，遇见何人，最后会变成什么样的人，但一定要记住，能让自己登高的，永远不是别人的肩膀，而是挑灯夜战的自己，人生的道路刚刚启程，当你累了倦了也不要迷茫，回头看一看，你早已不再是那个年少轻狂的少年。 .
算法面试题和答案
weixin_48077282的博客
11-05 617
算法的复杂性是一种分类算法与替代算法相比效率的方法。空间复杂度分析在计算的早期(当计算机上的存储空间有限时)至关重要。非常适合根据算法所需的相对时间量或相对空间量对算法进行分类，并将时间/空间需求的增长指定为输入大小的函数。算法是一个定义明确的计算过程，它将一些值或一组值作为输入，并产生一组值或一些值作为输出。它由在任何大小为 n 的实例上采取的最大步数定义。它由在任何大小为 n 的实例上采取的最小步数定义。它由在任何大小为 n 的实例上采取的平均步数定义。算法为设计者提供了对问题的需求和目标的强烈描述。
最全常见算法工程师面试题目整理
热门推荐
weixin_40355324的博客
03-14 4万+
最全算法工程师面试题目整理(一)2017-10-26 slade_sal 人工智能LeadAI沙韬伟，苏宁易购高级算法工程师。曾任职于Hewlett-Packard、滴滴出行。数据学院特邀讲师。主要研究方向包括风控、推荐和半监督学习。目前专注于基于深度学习及集成模型下的用户行为模式的识别。最近抽风，出去面试了不少公司，和不少算法工程师招聘的朋友有所交流，整理了相关比较有意思的题目，供大家参考：附：...
基础二叉树算法的C++实现
最新发布
11-10
基础二叉树算法的C++实现
最优二叉树算法
10-25
最优二叉树 最优二叉树算法
PHP构造二叉树算法示例
12-20
树（Tree）在数据结构还是很重要的，这里表示二叉树用括号表示法表示。先写一个二叉树节点类： // 二叉树节点 class BTNode { public $data; public $lchild = NULL; public $rchild = NULL; public function _...
二叉树算法
07-01
二叉树算法，二叉树的删除，添加，排序
面试10大算法汇总+常见题目解答
wuhua_amazing的专栏
12-16 3314
面试10大算法汇总＋常见题目解答 最近更新： 2013年12月15日 持续更新… 英文版的面试10大算法汇总日最高访问量已高达4,318次。这说明总结程序员面试算法有实际意义，比读算法书更有效。下面是中文版的10大算法汇总＋有代表性的题目汇总。这些概念是专门为面试准备的，因为日常编程中我们很少会自己去写一个链表或者做一个图，也不会
算法岗面试问题总结（一）
nihaomeimeiz的博客
03-01 579
python装饰器
29道面试基础算法题，试试看会不会
Android茶话会
05-25 3109
本文主要整理了一些面试常见的算法题，涵盖 数组、字符串、哈希表、链表、二叉树。
经典算法面试题
weixin_30756499的博客
07-03 342
1. 10亿个数中取前1000大的数 维护一个1000个节点的小顶堆。 时间复杂度O(nlogk) 2.合并k个有序（假设升序）数组 具体步骤：（1）将k个数组的第一个元素取出来，维护一个小顶堆。 　　　　　（2）弹出堆顶元素存入结果数组中，并把该元素所在数组的下一个元素取出来压入队中。 　　　　　（3）调整堆的结构，使其满足小顶堆的定义。 　　　　　（4）重复（2）（3）直...
常见算法面试题
liujiaping的专栏
01-13 523
常见算法面试题 1.字符串交换位置 时间复杂度O(n) 空间复杂度O(1) 输入 "abcde" 输出 "edcba" def jiaohuan(str1): s1 = list(str1) tmp = 0 for i in range(0, int(len(s1) / 2)): tmp = s1[i] s1[i] = s1[len(s1) - i - 1] s1[len(s1) - i - 1] = tmp
二叉树先序遍历
小飞的博客
02-26 7699
前两天面试，看见了个笔试题，关于二叉树的，今天算是把自己的一点理解写下来吧。 今天看网文，才想起来，二叉树的先序遍历、中序遍历、后序遍历， 遍历顺序都是相对于父节点写的，也就是先遍历父节点、中间遍历父节点，最后遍历父节点。 讲完理论，来看一下今天理解的一个二叉树题 先序遍历：FBACDEGH 中序遍历：ABDCEFGH 一下只适用于已知先序遍历和
最常见算法面试题
u010006156的博客
05-29 2917
文章目录 前言 一、算法好处 二、算法基础 三、五大算法思想 四、高频面试算法题 1.链表反转 2.环形链表 3.大数相加 4.冒泡排序优化 5.LRU实现 前言 算法题是现在面试必考题，作者通过最近面试复盘并总结一下相关的算法题，会持续更新。 一、算法好处 算法学习不仅仅是应付面试，更重要是思维得到了提升，特别是逻辑推理能力，在遇到大流量等业务场景下都需要用算法的思维做设计和优化，还有就是极限的压榨硬件的性能等等。 ps：千万别把学习算法当成应付面试，这样的心态很难学好算法。 二、算法基
二叉树-你必须要懂！（二叉树相关算法实现-iOS）
diemiekui4782的博客
10-23 297
这几天详细了解了下二叉树的相关算法，原因是看了唐boy的一篇博客（你会翻转二叉树吗？），还有一篇关于百度的校园招聘面试经历，深刻体会到二叉树的重要性。于是乎，从网上收集并整理了一些关于二叉树的资料，及相关算法的实现（主要是Objective-C的，但是算法思想是相通的），以便以后复习时查阅。 什么是二叉树？ 在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子...
rfid算法 二叉树算法
10-11
RFID算法是指一组用于实现无线射频识别功能的算法。...而二叉树算法是指一类基于二叉树数据结构的算法，主要用于搜索、排序、压缩和加密等领域。其中比较常见的二叉树算法有：二叉查找树、红黑树、B树和Huffman编码等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值