二叉树相关

最新推荐文章于 2024-07-08 22:12:26 发布
最新推荐文章于 2024-07-08 22:12:26 发布
阅读量155 收藏 1
点赞数 1
分类专栏： 数据结构与算法 文章标签： 二叉树 算法 数据结构 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42920104/article/details/111949041
版权

二叉平衡树原理及python实现

二叉平衡树（AVL树）基本定义

  1. AVL树里任一结点的左右子树高度（深度）差的绝对值小于等于1，绝对值就是平衡因子
  2. 任一结点的左右子树均为AVL树

AVL树是一种特殊的二叉搜索树 (BST树)，数据极端情况下, 二叉搜索树会退化成为单链表，但是AVL树通过旋转操作规避了这个问题。
查找平均复杂度：O（logn）
下面是基本节点定义

class TreeNode(object):
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
class AVLTree(object):
    def __init__(self):
        self.root = None

利用递归计算二叉平衡树的深度（高度）

注：下面的代码都是属于类AVLTree里的方法

def depth(self, node):
	if node is None:
	    return 0
	d1 = self.depth(node.left) # 计算node节点左子树的深度
	d2 = self.depth(node.right) # 计算node节点右子树的深度
	return max(d1, d2) + 1

二叉平衡树之插入节点

首先，二叉平衡树一棵二叉搜索树，其添加节点的方式同二叉搜索树一致。但按照这种方式添加（插入）节点会导致树中的某节点的平衡因子大于1，所以为了使得此树满足二叉平衡树的定义，在插入节点后需要对树中的不平衡点进行调整。根据不同的插入位置，一共有以下四种调整方法。

插入位置调整方式
插入结点在不平衡点右子树的右边LL调整，左旋转
插入结点在不平衡点左子树的左边RR调整，右旋转
插入结点在不平衡点左子树的右边LR调整，左右旋转
插入结点在不平衡点右子树的左边RL调整，右左旋转

注：不平衡点是第一个不满足这棵树是平衡二叉树的结点（平衡因子大于1），如果有多个结点同时不满足，就选最靠近下面的那个结点作为不平衡点。

RR调整

在这里插入图片描述
插入节点是2，上图的10是不平衡点，其左子树高度为2，右子树高度为0，平衡因子为2。需要进行右旋转，RR调整的代码如下：

 def right_rotate(self, root): # root是不平衡点
     if root is None:
          return
      # 创建新的结点，以当前根结点的值
      new_root = TreeNode(root.val)
      # 把新结点的右子树设为当前结点的右子树
      new_root.right = root.right
      # 把新结点的左子树设为当前结点的左子树的右子树
      new_root.left = root.left.right
      # 把当前结点的值替换成它的左子结点的值
      root.val = root.left.val
      # 把当前结点的左子树设置成当前结点的左子树的左子树
      root.left = root.left.left
      # 把当前结点的右子结点设置成（指向）新的结点
      root.right = new_root

RR调整后，整棵树如下图所示，满足二叉平衡树的定义
在这里插入图片描述

LL调整

在这里插入图片描述
插入节点是9，上图的7是不平衡点，其左子树高度为0，右子树高度为2，平衡因子为2。需要进行左旋转，LL调整的代码如下：

def left_rotate(self, root): # root是不平衡点
    if root is None:
        return
    # 创建新的结点，以当前根结点的值
    new_root = TreeNode(root.val)
    # 把新结点的左子树设为当前结点的左子树
    new_root.left =root.left
    # 把新结点的右子树设为当前结点的右子树的左子树
    new_root.right = root.right.left
    # 把当前结点的值替换成它的右子结点的值
    root.val = root.right.val
    # 把当前结点的右子树设置成当前结点的右子树的右子树
    root.right = root.right.right
    # 把当前结点的左子结点设置成（指向）新的结点
    root.left = new_root

LL调整后，整棵树如下图所示，满足二叉平衡树的定义
在这里插入图片描述

LR调整

在这里插入图片描述
插入节点是6，上图的7是不平衡点，其左子树高度为2，右子树高度为0，平衡因子为2。需要进行左右旋转（先对5节点进行左旋转变成RR调整的形式，再对7节点进行右旋转），LR调整的代码如下：

def left_right_rotate(self, root):
    self.left_rotate(root.left)
    self.right_rotate(root)

先进行左旋转，整棵树如下图所示，化成RR调整的形式
在这里插入图片描述
再进行右旋转，整棵树如下图所示，满足平衡二叉树的定义。
在这里插入图片描述

RL调整

在这里插入图片描述
插入节点是8，上图的7是不平衡点，其左子树高度为0，右子树高度为2，平衡因子为2。需要进行右左旋转（先对9节点进行右旋转变成LL调整的形式，再对7节点进行左旋转），RL调整的代码如下：

def right_left_rotate(self, root):
      self.right_rotate(root.right)
      self.left_rotate(root)

先进行右旋转，整棵树如下图所示，化成LL调整的形式
在这里插入图片描述
再进行左旋转，整棵树如下图所示，满足平衡二叉树的定义。
在这里插入图片描述

二叉平衡树之删除节点

二叉平衡树之寻找前继节点和后继节点

本文在不含父亲节点的数据结构下，分析给出了时间复杂度为O(lgN)的求前驱后继结点的算法。
前驱节点
若一个节点有左子树，那么该节点的前驱节点是其左子树中val值最大的节点.
若一个节点没有左子树，那么判断该节点和其父节点的关系.

  1. 若该节点是其父节点的右边孩子，那么该节点的前驱结点即为其父节点。
  2. 若该节点是其父节点的左边孩子，那么需要沿着其父亲节点一直向树的顶端寻找，直到找到一个节点P，P节点是其父节点Q的右边孩子（可参考例子2的前驱结点是1），那么Q就是该节点的后继节点

类似，我么可以得到求后继节点的规则。

后继节点
若一个节点有右子树，那么该节点的后继节点是其右子树中val值最小的节点（也就是右子树中所谓的leftMostNode）
若一个节点没有右子树，那么判断该节点和其父节点的关系
2.1 若该节点是其父节点的左边孩子，那么该节点的后继结点即为其父节点
2.2 若该节点是其父节点的右边孩子，那么需要沿着其父亲节点一直向树的顶端寻找，直到找到一个节点P，P节点是其父节点Q的左边孩子，那么Q就是该节点的后继节点

规则中我们是从下往上找，但实际代码中是不允许我们这么操作的（由于我们没有父亲指针），我们可以在寻找对应val节点的过程中从上向下找，并且过程中记录下parent节点和firstRParent节点（最后一次在查找路径中出现右拐的节点）。
python代码实现如下：

def getPreNode_val(self, val): # 默认该二叉平衡树非空，有根节点
    flag = True # 默认 值为val的节点没有左子树
    root = self.root
    Parent = None
    firstRParent = None
    while root:
        if val == root.val:
            node = root # 值为val的节点
            if root.left:
                flag = False
            break
        Parent = root
        if val < root.val:
            root = root.left
        elif val > root.val:
            firstRParent = root # 出现右拐点
            root = root.right
    if root is None: # 表明上述循环没有找到节点val
        print("值为%d的节点不存在前继节点"%val)
        return
    if Parent is None: # 表示上述循环内的Parent=root语句一次也未执行，此时查询的点即根节点
        node = root.left
        if node is None:
            return root.val
        else: 
            while node.right: # 只要一直有右孩子，就一直循环
                node = node.right
            return node.val
    else: # 查询的节点不是根节点
        if flag: # node节点没有左子树
            if val > Parent.val: # node节点是父亲节点的右孩子，此时Parent等于firstParent，firstParent没有意义
                return Parent.val
            elif val < Parent.val: # node节点是父亲节点的左孩子，此时Parent不等于firstParent，firstParent有意义
                if firstRParent is None:
                    return None # 没有前继节点
                else:
                    return firstRParent.val
        else: # node节点有左子树
            node = node.left
            while node.right: # 只要一直有右孩子，就一直循环
                node = node.right
            return node.val # 对于值为val的节点node,返回其左子树中val值最大的节点

求后继节点
同样，求后继节点我们不能从底向上找，也是从上向下找，首先是找到对应val值的节点，顺便把其的parent节点和firstlParent节点（最后一次在查找路径中出现左拐的节点）。
python代码实现如下：

def getNextNode_val(self, val):
    flag = True # 默认 值为val的节点没有右子树
    root = self.root
    Parent = None
    firstLParent = None
    while root:
        if val == root.val:
            node = root # 值为val的节点
            if root.right: # 有右孩子
                flag = False
            break
        Parent = root
        if val < root.val:
            firstLParent = root # 出现左拐点
            root = root.left
        elif val > root.val:
            root = root.right
    if root is None:
        print("值为%d的节点不存在后继节点"%val)
        return
    if Parent is None: # 表示上述循环内的Parent=root语句一次也未执行，此时查询的点即根节点
        node = root.right
        if node is None:
            return root.val
        else: 
            while node.left: # 只要一直有左孩子，就一直循环
                node = node.left
            return node.val
    else: # 查询的节点不是根节点
        if flag: # node节点没有右子树
            if val < Parent.val: # node节点是父亲节点的左孩子，此时Parent等于firstParent，firstParent没有意义
                return Parent.val
            elif val > Parent.val: # node节点是父亲节点的右孩子，此时Parent不等于firstParent，firstParent有意义
                if firstLParent is None:
                    return None
                else:
                    return firstLParent.val
        else: # node节点有右子树
            node = node.right
            while node.left: # 只要一直有左孩子，就一直循环
                node = node.left
            return node.val # 对于值为val的节点node,返回其左子树中val值最大的节点

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

def isblanced(self, root):
    def height(node):
        if not node:return 0
        left = height(node.left)
        right = height(node.right)
        if left == -1 or right == -1 or abs(left-right) > 1:
            return -1

        return max(left,right) + 1
    return height(root) != -1

二叉平衡树之先序遍历、中序遍历

# 中序遍历测试
def in_order(self, node):
    if node is None:
        return
    self.in_order(node.left)
    print(node.val, end=" ")
    self.in_order(node.right)

# 前序遍历测试（主要看根结点的变化）
def pre_order(self, node):
    if node is None:
        return
    print(node.val, end=" ")
    self.pre_order(node.left)
    self.pre_order(node.right)

二叉平衡树全部代码

class TreeNode(object):
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None


class AVLTree(object):
    def __init__(self):
        self.root = None
        self.P = 0
    
    
    def getpower(self):
        return self.P
    
    
    def depth(self, node):
        if node is None:
            return 0
        d1 = self.depth(node.left)
        d2 = self.depth(node.right)
        return max(d1, d2) + 1
        
        
    def left_rotate(self, root):
        if root is None:
            return
        # 创建新的结点，以当前根结点的值
        new_root = TreeNode(root.val)
        # 把新结点的左子树设为当前结点的左子树
        new_root.left =root.left
        # 把新结点的右子树设为当前结点的右子树的左子树
        new_root.right = root.right.left
        # 把当前结点的值替换成它的右子结点的值
        root.val = root.right.val
        # 把当前结点的右子树设置成当前结点的右子树的右子树
        root.right = root.right.right
        # 把当前结点的左子结点设置成（指向）新的结点
        root.left = new_root
    def right_rotate(self, root):
        if root is None:
            return
        # 创建新的结点，以当前根结点的值
        new_root = TreeNode(root.val)
        # 把新结点的右子树设为当前结点的右子树
        new_root.right = root.right
        # 把新结点的左子树设为当前结点的左子树的右子树
        new_root.left = root.left.right
        # 把当前结点的值替换成它的左子结点的值
        root.val = root.left.val
        # 把当前结点的左子树设置成当前结点的左子树的左子树
        root.left = root.left.left
        # 把当前结点的右子结点设置成（指向）新的结点
        root.right = new_root
    def left_right_rotate(self, root):
        self.left_rotate(root.left)
        self.right_rotate(root)
    def right_left_rotate(self, root):
        self.right_rotate(root.right)
        self.left_rotate(root)

    """# 非递归添加结点
    def insert(self, node):
        if self.root is None:
            self.root = node
            return
        queue = [self.root]
        while queue:
            temp_node = queue.pop(0)
            # 判断传入结点的值和当前子树结点的值关系
            if node.val < temp_node.val:
                if temp_node.left is None:
                    temp_node.left = node
                    return
                else:
                    queue.append(temp_node.left)
            if node.val >= temp_node.val:
                if temp_node.right is None:
                    temp_node.right = node
                    return
                else:
                    queue.append(temp_node.right)
    """
    
    # 递归添加结点
    def insert(self, root, val):
        node = TreeNode(val)
        if root is None:
            self.root = node
            return
        if val < root.val:
            if not root.left: # 根的左子树是空的
                root.left = node
                return
            else:
                self.insert(root.left, val)
                if self.depth(root.left) - self.depth(root.right) >= 2:
                    if val < root.left.val:
                        self.right_rotate(root)
                    else:
                        self.left_right_rotate(root)
        else:
            if not root.right: # 根的右子树是空的
                root.right = node
                return
            else:
                self.insert(root.right, val)
                if self.depth(root.right) - self.depth(root.left) >= 2: # 这里的root就是指“递归添加结点那里传入的root”
                    if val > root.right.val:
                        self.left_rotate(root)
                    else:
                        self.right_left_rotate(root)
                        
    def remove(self, root, val):
        

    def isblanced(self, root):
        def height(node):
            if not node:return 0
            left = height(node.left)
            right = height(node.right)
            if left == -1 or right == -1 or abs(left-right) > 1:
                return -1

            return max(left,right) + 1
        return height(root) != -1
    
    def getPreNode_val(self, val): # 默认该二叉平衡树非空，有根节点
        flag = True # 默认 值为val的节点没有左子树
        root = self.root
        Parent = None
        firstRParent = None
        while root:
            if val == root.val:
                node = root # 值为val的节点
                if root.left:
                    flag = False
                break
            Parent = root
            if val < root.val:
                root = root.left
            elif val > root.val:
                firstRParent = root # 出现右拐点
                root = root.right
        if root is None: # 表明上述循环没有找到节点val
            print("值为%d的节点不存在前继节点"%val)
            return
        if Parent is None: # 表示上述循环内的Parent=root语句一次也未执行，此时查询的点即根节点
            node = root.left
            if node is None:
                return root.val
            else: 
                while node.right: # 只要一直有右孩子，就一直循环
                    node = node.right
                return node.val
        else: # 查询的节点不是根节点
            if flag: # node节点没有左子树
                if val > Parent.val: # node节点是父亲节点的右孩子，此时Parent等于firstParent，firstParent没有意义
                    return Parent.val
                elif val < Parent.val: # node节点是父亲节点的左孩子，此时Parent不等于firstParent，firstParent有意义
                    if firstRParent is None:
                        return None # 没有前继节点
                    else:
                        return firstRParent.val
            else: # node节点有左子树
                node = node.left
                while node.right: # 只要一直有右孩子，就一直循环
                    node = node.right
                return node.val # 对于值为val的节点node,返回其左子树中val值最大的节点
        
    def getNextNode_val(self, val):
        flag = True # 默认 值为val的节点没有右子树
        root = self.root
        Parent = None
        firstLParent = None
        while root:
            if val == root.val:
                node = root # 值为val的节点
                if root.right: # 有右孩子
                    flag = False
                break
            Parent = root
            if val < root.val:
                firstLParent = root # 出现左拐点
                root = root.left
            elif val > root.val:
                root = root.right
        if root is None:
            print("值为%d的节点不存在后继节点"%val)
            return
        if Parent is None: # 表示上述循环内的Parent=root语句一次也未执行，此时查询的点即根节点
            node = root.right
            if node is None:
                return root.val
            else: 
                while node.left: # 只要一直有左孩子，就一直循环
                    node = node.left
                return node.val
        else: # 查询的节点不是根节点
            if flag: # node节点没有右子树
                if val < Parent.val: # node节点是父亲节点的左孩子，此时Parent等于firstParent，firstParent没有意义
                    return Parent.val
                elif val > Parent.val: # node节点是父亲节点的右孩子，此时Parent不等于firstParent，firstParent有意义
                    if firstLParent is None:
                        return None
                    else:
                        return firstLParent.val
            else: # node节点有右子树
                node = node.right
                while node.left: # 只要一直有左孩子，就一直循环
                    node = node.left
                return node.val # 对于值为val的节点node,返回其左子树中val值最大的节点
                
                

    # 中序遍历测试
    def in_order(self, node):
        if node is None:
            return
        self.in_order(node.left)
        print(node.val, end=" ")
        self.in_order(node.right)

    # 前序遍历测试（主要看根结点的变化）
    def pre_order(self, node):
        if node is None:
            return
        print(node.val, end=" ")
        self.pre_order(node.left)
        self.pre_order(node.right)


if __name__ == '__main__':
    a = AVLTree()
    # 测试左旋转结点值数组
    # node_array = [4, 3, 6, 5, 7, 8]
    # 测试右旋转结点值数组
    # node_array = [10, 12, 8, 9, 7, 6]
    # 测试双旋转结点数组
    node_array = [10, 11, 7, 6, 8, 9]
    for item in node_array:
        a.insert(a.root, item)
#         a.insert(item)
#     a.judge_node(a.root)
    print("中序遍历结果为：")
    a.in_order(a.root)
    print()
    print("旋转后，前序遍历结果为：")
    a.pre_order(a.root)
    print()
    print("树的高度为:", a.depth(a.root))
    print("左子树高度为：", a.depth(a.root.left))
    print("右子树高度为：", a.depth(a.root.right))

如果本文章对你有帮助的话，麻烦点个赞哦，谢谢！！！

飞与幻的assassin
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PTA数据结构--二叉树（判断题和选择题）
HSBnn的博客
12-23 5082
这里写自定义目录标题判断题选择题 判断题 选择题 撤销：Ctrl/Command + Z 重做：Ctrl/Command + Y 加粗：Ctrl/Command + B 斜体：Ctrl/Command + I 标题：Ctrl/Command + Shift + H 无序列表：Ctrl/Command + Shift + U 有序列表：Ctrl/Command + Shift + O 检查列表：Ctrl/Command + Shift + C 插入代码：Ctrl/Command + Shift + K 插入链
7.2 二叉树的基本运算及遍历的python实现
xutiantian1412的博客
04-23 1119
这几节内容，概念少，全靠代码撑住场面。多看代码，才能学习到二叉树的基本知识和应用。 二叉树的基本运算 所谓的基本运算主要包括：括号表示法的树与二叉链存储结构的树互相转换，树节点查找，求树高度。 1. 树节点查找： 最基本的操作了： class TreeNode: # 树节点的定义 def __init__(self, val): self.data = val...
Python实现二叉搜索树(BST)及其基本操作详解
jacobbubushiqi的博客
01-19 468
二叉搜索树（Binary Search Tree，简称BST）是一种常用的数据结构，其特点在于每个节点的值大于其左子树中任意节点的值，小于其右子树中任意节点的值。这种性质使得在BST中进行搜索、插入和删除等操作非常高效。在本文中，我们将通过Python代码实现BST及其基本操作，包括节点的插入、查询、删除以及不同遍历方式的演示。首先，我们定义了二叉搜索树的节点类BiTreeNode。每个节点包含数据、左孩子、右孩子和父节点。# 节点初始化，包括数据、左孩子、右孩子和父节点。
python-6. 重建二叉树
Bo's Blog
05-09 156
题目描述： 输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树，假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如，输入前序遍历序列{1，2，4，7，3，5，6，8}和中序遍历序列{4, 7, 2, 1, 5, 3, 8, 6}，则重建如下图所示的二叉树并输出它的头结点。二叉树节点的定义如下： struct BinaryTreeNode { int m_nValue...
08_Python算法+数据结构笔记-二叉搜索树查询/删除-AVL树旋转/插入/应用-贪心算法
cPen_web的博客
12-27 350
b站视频:路飞IT学城 https://www.bilibili.com/video/BV1mp4y1D7UP 文章目录#71 二叉搜索树：查询#72 二叉搜索树：删除#73 二叉搜索树：删除实现#74 AVL树的概念#75 AVL旋转#76 AVL：旋转实现1#77 AVL：旋转实现2#78 AVL：插入#79 AVL树应用与数据结构总结#80 贪心算法 个人博客 https://blog.csdn.net/cPen_web #71 二叉搜索树：查询 import random class BiTree
关于树的一些题
whr
05-22 9153
关于树的一些习题
二叉树相关操作
01-04
二叉树基本操作：定义、建立、输入、输出等操作以及各种遍历，交换using namespace std; //二叉树定义 typedef char ElementType; typedef struct BiTreeNode { ElementType data; struct BiTreeNode* lchild; ...
二叉树相关算法.rar
09-22
在面试中，二叉树相关的问题是常见的考察点，尤其是非递归的算法实现，因为它们能体现候选人的逻辑思维能力和空间复杂度控制。下面我们将详细探讨八种可能的二叉树算法，以及如何非递归地解决它们。 1. **遍历**：...
C语言二叉树相关的代码.zip
10-27
下面我们将深入探讨二叉树的相关知识点。 1. **二叉树的定义** 在C语言中，二叉树可以通过定义一个结构体来实现。基本结构通常包括节点值、指向左子节点和右子节点的指针。例如： ```c typedef struct TreeNode ...
datawhale第五次打卡博客class TreeNode: def __init__(self,val): self.val=val; self.left=None; self.ri
qq_41484845的博客
05-21 2674
实现一个二叉查找树，并且支持插入、删除、查找操作 实现查找二叉查找树中某个节点的后继、前驱节点 实现二叉树前、中、后序以及按层遍历 class TreeNode: def __init__(self,val): self.val=val; self.left=None; self.right=None; def insert(root,val):#插入 if root is...
平衡树详解（Splay）
热门推荐
Wu_while的博客
08-29 1万+
引入 先看例题：（洛谷 P3369 【模板】普通平衡树） 您需要写一种数据结构，来维护一些数，其中需要提供以下操作： 1.插入 xxx 数 2.删除 xxx 数(若有多个相同的数，因只删除一个) 3.查询 xxx 数的排名(排名定义为比当前数小的数的个数 +1+1+1 ) 4.查询排名为 xxx 的数 5.求 xxx 的前驱(前驱定义为小于 xxx，且最大的数) 6.求 xxx 的后继(后继定义为大于 xxx，且最小的数) 显然可以使用BST（二叉搜索树）完成，它的时间复杂度是 O(logn)O(log
AVL树（平衡二叉树）
maozezhong0的博客
07-15 762
一颗AVL树是其每个节点的左子树和右子树的高度最多差1的二叉查找树（空树的高度定位-1）。 二叉查找树的性质：对于树中的每个节点X，它的左子树中所有项的值小于X中的项，而它的右子树的所有项的值大于X中的项。AVL树的插入在树中插入一个值可能破坏AVL树的性质，所以我们要对树进行调整，这一操作就是**旋转**。 在插入以后，只有从插入点到根节点的的路径上的节点的平衡可能改变，因为只有这些节点的子树可
红黑树详解
lixinkuan的博客
10-08 330
在记录红黑树结构之前，先了解一下平衡二叉树 满二叉树 满二叉树：除了叶子结点外其他节点均有左右孩子节点 avl树对中平衡二叉树的要求 avl中的二叉树，对于任意一个节点，其左子树和右子树的高度差不能超过一 堆中的完全二叉树 完全二叉树：将节点按照从左到右一层一层的结构全部铺开即为满二叉树，完全二叉树的空缺部分一定在二叉树的右下部分，且整个树的叶子节点，最大深度值和最下深度值...
算法导论-透彻了解平衡二叉树（AVL树）
weixin_33720452的博客
10-22 152
一.平衡二叉树简介 形态匀称的二叉排序树称为平衡二叉树 (Balanced binary tree) ，其每个结点的左子树和右子树的高度最多差1,严格定义是： 一棵空树是平衡二叉树；若 T 是一棵非空二叉树，其左、右子树为 TL 和 TR ，令 hl 和 hr 分别为左、右子树的深度。当且仅当 1)TL 、 TR 都是平衡二叉树； 2)｜ hl － hr ｜≤ 1...
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 856
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
十一、作业
weixin_58543820的博客
07-07 494
计算1/1-1/2+1/3-1/4+1/5 ……+ 1/99 - 1/100 的值，打印出结果。编写程序数一下 1到 100 的所有整数中出现多少个数字9。要求：找到了就打印数字所在的下标，找不到则输出：找不到。写一个代码打印1-100之间所有3的倍数的数字。编写代码在一个整形有序数组中查找具体的某个数。打印1000年到2000年之间的闰年。写代码将三个整数数按从大到小输出。给定两个数，求这两个数的最大公约数。最小公倍数=a*b/最大公约数。在屏幕上输出9*9乘法口诀表。%-2d - 左对齐。
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 1240
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。
【算法笔记自学】第 5 章 入门篇（3）——数学问题
qq_62704693的博客
07-06 2027
【代码】【算法笔记自学】入门篇（3）——数学问题。
树与二叉树有关的编程题
04-24
可以有很多树和二叉树相关的编程题，以下是几个例子： 1. 遍历二叉树：写一个函数，按照前序、中序、后序遍历顺序依次输出二叉树中的节点值。 2. 二叉树的最大深度：写一个函数，返回二叉树的最大深度。 3. 判断...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值