求树的高度

递归算法

int high(Tree r)
{
    if(r==NULL)
        return 0;
    int left=high(r->lchild);
    int right=high(r->rchild);
    return (left>right? left:right)+1;
}

非递归算法

**每访问到一层的最右结点就高度+1,怎么定位每一层的最右结点呢??**
每进入一个结点,enquenumber就+1,这实质上是上一层全部出队列时把孩子都压入到队列中,最后压入得到的这一层的最后一个结点就是当前层的最右结点,并且它的序号是enquenumber,把这个序号再赋值给lastlevelNumber,这也有点像是一个递归过程,草稿纸上画图会理解得更加透彻.
int calculateTreeHeight(Tree r)
{
    if(r == NULL)
        return 0;
    int visitedNumber = 0;
    int enQueNumber = 1; //当前入队的序号,root为1
    int lastLevelNumber = 1;  //第一次最后一个结点的序号是1
    int height = 0;
    queue<Node*> q;
    q.push(root);
    while(!q.empty())
    {
        Node *node = q.front();
        q.pop();
        visitedNumber++;

        if(node->left != NULL)
        {
            q.push(node->left);
            enQueNumber++;
        }
        if(node->right != NULL)
        {
            q.push(node->right);
            enQueNumber++;
        }
        //访问到当前level上的最后一个节点
        if(visitedNumber == lastLevelNumber)
        {
            height++;
            lastLevelNumber = enQueNumber;
        }
    }
    return height;
}
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
链式存储二叉树的构建可以使用链表来实现,每个节点包含左右子节点的指针。以下是实现查找、求树高度、中序遍历、先遍历、后序遍历和层序遍历的程序: ```python class Node: def __init__(self, data): self.data = data self.left = None self.right = None class BinaryTree: def __init__(self): self.root = None def insert(self, data): node = Node(data) if self.root is None: self.root = node else: queue = [self.root] while queue: curr = queue.pop(0) if curr.left is None: curr.left = node break elif curr.right is None: curr.right = node break else: queue.append(curr.left) queue.append(curr.right) def search(self, data): if self.root is None: return False else: queue = [self.root] while queue: curr = queue.pop(0) if curr.data == data: return True if curr.left is not None: queue.append(curr.left) if curr.right is not None: queue.append(curr.right) return False def height(self): if self.root is None: return 0 else: queue = [self.root] height = 0 while True: level_size = len(queue) if level_size == 0: return height height += 1 while level_size > 0: curr = queue.pop(0) if curr.left is not None: queue.append(curr.left) if curr.right is not None: queue.append(curr.right) level_size -= 1 def inorder(self, node): if node is not None: self.inorder(node.left) print(node.data, end=' ') self.inorder(node.right) def preorder(self, node): if node is not None: print(node.data, end=' ') self.preorder(node.left) self.preorder(node.right) def postorder(self, node): if node is not None: self.postorder(node.left) self.postorder(node.right) print(node.data, end=' ') def levelorder(self): if self.root is None: return queue = [self.root] while queue: curr = queue.pop(0) print(curr.data, end=' ') if curr.left is not None: queue.append(curr.left) if curr.right is not None: queue.append(curr.right) # 测试代码 tree = BinaryTree() tree.insert(1) tree.insert(2) tree.insert(3) tree.insert(4) tree.insert(5) tree.insert(6) tree.insert(7) print(tree.search(5)) # True print(tree.search(8)) # False print(tree.height()) # 3 tree.inorder(tree.root) # 4 2 5 1 6 3 7 print() tree.preorder(tree.root) # 1 2 4 5 3 6 7 print() tree.postorder(tree.root) # 4 5 2 6 7 3 1 print() tree.levelorder() # 1 2 3 4 5 6 7 print() ``` 时间复杂度: - 插入节点:O(n),其中 n 为节点数,最坏情况下需要遍历所有节点。 - 查找节点:O(n),最坏情况下需要遍历所有节点。 - 求树高度:O(n),最坏情况下需要遍历所有节点。 - 中序遍历、先序遍历、后序遍历:O(n),需要遍历所有节点。 - 层序遍历:O(n),需要遍历所有节点。 空间复杂度: - 插入节点、查找节点、求树高度、中序遍历、先序遍历、后序遍历、层序遍历:O(n),需要存储所有节点。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值