AVL 树的初步认识与基本操作

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

历史

AVL 树是一种自平衡二叉搜索树，由托尔·哈斯特罗姆在 1960 年提出并在 1962 年发表。它的名字来源于发明者的名字：Adelson-Velsky 和 Landis，他们是苏联数学家，于 1962 年发表了一篇论文，详细介绍了 AVL 树的概念和性质。

在二叉搜索树中，如果插入的元素按照特定的顺序排列，可能会导致树变得非常不平衡，从而降低搜索、插入和删除的效率。为了解决这个问题，AVL 树通过在每个节点中维护一个平衡因子来确保树的平衡。平衡因子是左子树的高度减去右子树的高度。如果平衡因子的绝对值大于等于 2，则通过旋转操作来重新平衡树。

AVL 树是用于存储有序数据的一种重要数据结构，它是二叉搜索树的一种改进和扩展。它不仅能够提高搜索、插入和删除操作的效率，而且还能够确保树的深度始终保持在 O(log n) 的水平。随着计算机技术的不断发展，AVL 树已经成为了许多高效算法和系统中必不可少的一种基础数据结构。

什么叫平衡二叉搜索树?什么叫不平衡二叉搜索树？

个人理解：

答：当根节点两边左右孩子都有则为平衡二叉搜索树，如果有一边没有孩子就是不平衡，就像一个人如果缺胳膊少腿肯定就会看起来不平衡。

温馨提示：对于二叉树还是不太认识的，作者推荐：二叉搜索树的初步认识_加瓦不加班的博客-CSDN博客

前面介绍过，如果一棵二叉搜索树长的不平衡，那么查询的效率会受到影响，如下图

比如，我们如果要从上述二叉树，根节点是3，它虽然有左孩子，你有没有发现它右孩子没有，那岂不就是缺胳膊少腿？所以这个就是不平衡二叉搜索树，

那么为什么一棵二叉搜索树长的不平衡会查询的效率会受到影响？

答：比如，你现在要搜索节点为1的情况，你要从根节点开始，从根往左，也就是搜索到最低层节点才能找到，也就是要走2步，如果，此时我将2做为根节点，那么从2开始查询，只需要一步到位查询到1.是不是相对平衡的二叉树搜索起来更加高效？

通过旋转可以让树重新变得平衡，并且不会改变二叉搜索树的性质（即左边仍然小，右边仍然大）

什么叫自平衡二叉搜索树？

就是当二叉树出现不平衡时，我们二叉树能够检测不平衡，通过“旋转”，也就是自动将根节点调换，换成能够变成平衡二叉树的情况。

/**

  • ​

    AVL 树

  • <li>二叉搜索树在插入和删除时，节点可能失衡</li>

  • <li>如果在插入和删除时通过旋转, 始终让二叉搜索树保持平衡, 称为自平衡的二叉搜索树</li>

  • <li>AVL 是自平衡二叉搜索树的实现之一</li>

  • </ul> */

如何判断失衡？

如果一个节点的左右孩子，高度差超过 1，则此节点失衡，才需要旋转

处理高度

如何得到节点高度？一种方式之前做过的一道题目：E05. 求二叉树的最大深度（高度）二叉树--二叉树最大深度_加瓦不加班的博客-CSDN博客，但由于求高度是一个非常频繁的操作，因此将高度作为节点的一个属性，将来新增或删除时及时更新，默认为 1（按力扣说法）

static class AVLNode {
    int height = 1;
    int key;
    Object value;
    AVLNode left;
    AVLNode right;
    // ...
}

求高度代码：

这里加入了 height 函数方便求节点为 null 时的高度

private int height(AVLNode node) {
    return node == null ? 0 : node.height;
}

更新高度代码

将来新增、删除、旋转时，高度都可能发生变化，需要更新。下面是更新高度的代码

在这里我们之前其实已经学习了如何获取节点的高度----二叉树最大深度-力扣104二叉树--二叉树最大深度_加瓦不加班的博客-CSDN博客

/*
   思路：
   1. 得到左子树深度, 得到右子树深度, 二者最大者加一, 就是本节点深度
   2. 因为需要先得到左右子树深度, 很显然是后序遍历典型应用
   3. 关于深度的定义：从根出发, 离根最远的节点的总边数,这个总边数指的就是下面的线段数
       注意: 力扣里的深度定义要多一,在你现在看来下面的深度确实是1 2 0  但是力扣官方觉得：在你看来的基础上+1才是正确的深度

 你的视角：      深度:1         深度:2         深度:0
 力扣的视角：      深度:2         深度:3         深度:1
                   1            1            1
                  / \          / \
                 2   3        2   3
                                   \
                                    4
*/
   public int maxDepth(TreeNode node) {
       if (node == null) {
           return 0; // 非力扣题目改为返回 -1
       }
       int d1 = maxDepth(node.left);
       int d2 = maxDepth(node.right);
       return Integer.max(d1, d2) + 1;
   }

举例说明：

当二叉树只有根节点时，高度是1：

当二叉树有根节点跟一边的子节点时，根节点高度是2 子节点是1：（实际上是想告诉你的是，任何一个节点在新增以后的高度都是要变化的）：

但是有一种情况是不会变化的，那就是当在同一层加节点，高度不变：

private void updateHeight(AVLNode node) {
    node.height = Integer.max(height(node.left), height(node.right)) + 1;
}

何时触发失衡判断？

定义平衡因子（balance factor）如下

当平衡因子

  • bf = 0，1，-1 时，表示左右平衡

为什么会有0，1，-1的情况？

举例说明：

对于0这个情况：

对于4节点为参考，它的左右孩子高度相减就是0

对于1这个情况：

对于4根节点为参考，它的左孩子高度为2，右孩子高度为1，而我们相减的顺序是（左-右） ，相减就是1

对于-1这个情况：

对于2根节点为参考，它的左孩子高度为1，右孩子高度为2，而我们相减的顺序是（左-右） ，相减就是-1

  • bf > 1 时，表示左边太高

  • bf < -1 时，表示右边太高

对应代码

private int bf(AVLNode node) {
    return height(node.left) - height(node.right);
}

当插入新节点，或删除节点时，引起高度变化时，例如

目前此树平衡，当再插入一个 4 时，节点们的高度都产生了相应的变化，8 节点失衡了

在比如说，下面这棵树一开始也是平衡的

当删除节点 8 时，节点们的高度都产生了相应的变化，6 节点失衡了

失衡的四种情况

LL

  • 失衡节点（图中 8 红色）的 bf > 1，即左边更高

  • 失衡节点的左孩子（图中 6）的 bf >= 0 ，即图中 6的左孩子这边也是左边更高或等高

LR

  • 失衡节点（图中 8）的 bf > 1，即左边更高

  • 失衡节点的左孩子（图中 3 红色）的 bf < 0 ，即左孩子（图中 3 红色）这边是右边孩子更高

对称的还有两种情况

接下来的两个情况和上面两种情况是对称的：

RL

  • 失衡节点（图中 3）的 bf <-1，即右边更高

  • 失衡节点的右孩子（图中 6 红色）的 bf > 0，即右孩子（图中 6 红色）这边左边更高

RR

  • 失衡节点（图中 3）的 bf <-1，即右边更高

  • 失衡节点的右孩子（图中 5 红色）的 bf <= 0，即右孩子（图中 5 红色）这边右边更高或等高

解决失衡

失衡可以通过树的旋转解决。什么是树的旋转呢？它是在不干扰元素顺序的情况下更改结构，通常用来让树的高度变得平衡。

观察下面一棵二叉搜索树，可以看到，旋转后，并未改变树的左小右大特性，但根、父、孩子节点都发生了变化

      4                                          2
     / \             4 right                  / \
    2   5      -------------------->    1   4
   / \         <--------------------      / \
  1   3              2 left               3   5

右旋

  • 红色节点，旧根（失衡节点）

  • 黄色节点，旧根的左孩子，将来作为新根，旧根是它右孩子

  • 绿色节点，新根的右孩子，将来要换爹作为旧根的左孩子

旋转后

代码

//参数：要旋转的节点 也就是失衡节点 
private AVLNode rightRotate(AVLNode red) {
    //黄色节点，旧根的左孩子
    AVLNode yellow = red.left;
    //绿色节点：当黄色节点有右孩子不是null，则要执行下面的red.left = green;  如果黄色节点有右孩子是null，就不需要执行red.left = green; 
    //但是如果黄色节点有右孩子是null 执行red.left = green; 指向Null也没事
    AVLNode green = yellow.right;
    yellow.right = red;
    red.left = green;
    //做完失衡调整以后 记得要做更新高度操作 更新高度的操作不能改变
    updateHeight(red);
    updateHeight(yellow);
    return yellow;
}

左旋

旋转前

  • 红色节点，旧根（失衡节点）

  • 黄色节点，旧根的右孩子，将来作为新根，旧根是它左孩子

  • 绿色节点，新根的左孩子，将来要换爹作为旧根的右孩子

旋转后

代码 ：与右旋的代码相对

private AVLNode leftRotate(AVLNode red) {
    AVLNode yellow = red.right;
    AVLNode green = yellow.left;
    yellow.left = red;
    red.right = green;
    //做完失衡调整以后 记得要做更新高度操作 更新高度的操作不能改变
    updateHeight(yellow);
    updateHeight(red);
    return yellow;
}

左右旋

指先左旋左子树，再右旋根节点（失衡），这时一次旋转并不能解决失衡

左子树旋转后

根右旋前

根右旋后

代码

private AVLNode leftRightRotate(AVLNode root) {
    root.left = leftRotate(root.left);
    return rightRotate(root);
}

右左旋

指先右旋右子树，再左旋根节点（失衡）

右子树右旋后

 根左旋前

根左旋后

代码

private AVLNode rightLeftRotate(AVLNode root) {
    root.right = rightRotate(root.right);
    return leftRotate(root);
}

你发现有这四种不平衡情况，其实基本操作就是左旋和右旋这两种。

判断及调整平衡代码

//检查节点是否失衡，重新平衡代码
private AVLNode balance(AVLNode node) {
    if (node == null) {
        return null;
    }
    int bf = bf(node);
    
    if (bf > 1 && bf(node.left) >= 0) { //LL
        return rightRotate(node);
    } else if (bf > 1 && bf(node.left) < 0) { //LR
        return rightLeftRotate(node);
    } else if (bf < -1 && bf(node.right) > 0) { //RL
        return leftRightRotate(node);
    } else if (bf < -1 && bf(node.right) <= 0) {//RR
        return rightRotate(node);
    }
    return node;
}

以上四种旋转代码里，都需要更新高度，需要更新高度的节点只有红色、黄色，而绿色节点与其他无色节点高度是不变的

新增操作

AVLNode root;
public void put(int key, Object value) {
    root = doPut(root, key, value);
}
//传来的根节点
private AVLNode doPut(AVLNode node, int key, Object value) {
    //1.找到空位  创建新节点
    if (node == null) {
        return new AVLNode(key, value);
    }
    //2.Key已存在，则更新
    if (key == node.key) {
        node.value = value;
        return node;
    }
    if (key < node.key) {
        node.left = doPut(node.left, key, value);
    } else {
        node.right = doPut(node.right, key, value);
    }
    updateHeight(node);
    return balance(node);
}

删除操作

public void remove(int key) {
    root = doRemove(root, key);
}

//node:传入的根节点
private AVLNode doRemove(AVLNode node, int key) {
    // 1. node == null
    if (node == null) {
        return null;
    }
    // 2. 没找到 key
    if (key < node.key) {
        node.left = doRemove(node.left, key);
    } else if (node.key < key) {
        node.right = doRemove(node.right, key);
    } else {
        // 3. 找到 key  1) 没有孩子 2) 只有一个孩子 3) 有两个孩子
        if (node.left == null && node.right == null) { //1) 没有孩子
            return null;
        } else if (node.left == null) { //2) 只有一个孩子
            node = node.right;
        } else if (node.right == null) {//2) 只有一个孩子
            node = node.left;
        } else { //3) 有两个孩子
            AVLNode s = node.right; //初始是待删除的右子树  
            //当后继节点与待删除节点不是相邻的
            while (s.left != null) {
                s = s.left;
            }
            //找到后继节点:s
            s.right = doRemove(node.right, s.key);//如果后继节点也有孩子，要把后继节点的孩子处理好
            s.left = node.left;
            //后继节点代替待删除节点
            node = s;
        }
    }
    if (node == null) {
        return null;
    }
    // 4. 更新高度
    updateHeight(node);
    // 5. balance
    return balance(node);
}

完整代码备份

public class AVLTree {
    static class AVLNode {
        int height = 1;
        int key;
        Object value;
        AVLNode left;
        AVLNode right;

        public AVLNode(int key) {
            this.key = key;
        }

        public AVLNode(int key, Object value) {
            this.key = key;
            this.value = value;
        }

        public AVLNode(int key, Object value, AVLNode left, AVLNode right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }

    AVLNode root;

    private AVLNode leftRotate(AVLNode p) {
        AVLNode r = p.right;
        AVLNode b = r.left;
        r.left = p;
        p.right = b;
        //做完失衡调整以后 记得要做更新高度操作 更新高度的操作不能改变
        updateHeight(p);
        updateHeight(r);
        return r;
    }

    private void updateHeight(AVLNode node) {
        node.height = Integer.max(height(node.left), height(node.right)) + 1;
    }

    private AVLNode rightRotate(AVLNode r) {
        AVLNode a = r.left;
        AVLNode b = a.right;
        a.right = r;
        r.left = b;
        //做完失衡调整以后 记得要做更新高度操作  更新高度的操作不能改变
        updateHeight(r);
        updateHeight(a);
        return a;
    }

    private AVLNode leftRightRotate(AVLNode p) {
        AVLNode r = p.left;
        p.left = leftRotate(r);
        return rightRotate(p);
    }

    private AVLNode rightLeftRotate(AVLNode p) {
        AVLNode r = p.right;
        p.right = rightRotate(r);
        return leftRotate(p);
    }

    private int height(AVLNode node) {
        return node == null ? 0 : node.height;
    }



    public void remove(int key) {
        root = doRemove(root, key);
    }

    private AVLNode doRemove(AVLNode node, int key) {
        if (node == null) {
            return null;
        }
        if (key < node.key) {
            node.left = doRemove(node.left, key);
        } else if (node.key < key) {
            node.right = doRemove(node.right, key);
        } else {
            if (node.left == null) {
                node = node.right;
            } else if (node.right == null) {
                node = node.left;
            } else {
                AVLNode s = node.right;
                while (s.left != null) {
                    s = s.left;
                }
                s.right = doRemove(node.right, s.key);
                s.left = node.left;
                node = s;
            }
        }
        if (node == null) {
            return null;
        }
        updateHeight(node);
        return balance(node);
    }

    public void put(int key, Object value) {
        root = doPut(root, key, value);
    }

    private AVLNode doPut(AVLNode node, int key, Object value) {
        if (node == null) {
            return new AVLNode(key, value);
        }
        if (key == node.key) {
            node.value = value;
            return node;
        }
        if (key < node.key) {
            node.left = doPut(node.left, key, value);
        } else {
            node.right = doPut(node.right, key, value);
        }
        updateHeight(node);
        return balance(node);
    }

    private int bf(AVLNode node) {
        return height(node.left) - height(node.right);
    }

    private AVLNode balance(AVLNode node) {
        if (node == null) {
            return null;
        }
        int bf = bf(node);
        if (bf > 1 && bf(node.left) >= 0) {
            return rightRotate(node);
        } else if (bf > 1 && bf(node.left) < 0) {
            return rightLeftRotate(node);
        } else if (bf < -1 && bf(node.right) > 0) {
            return leftRightRotate(node);
        } else if (bf < -1 && bf(node.right) <= 0) {
            return rightRotate(node);
        }
        return node;
    }
}

小结

AVL树的优点：

  1. AVL树是一种自平衡树，保证了树的高度平衡，从而保证了树的查询和插入操作的时间复杂度均为O(logn)。

  2. 相比于一般二叉搜索树，AVL树对查询效率的提升更为显著，因为其左右子树高度的差值不会超过1，避免了二叉搜索树退化为链表的情况，使得整棵树的高度更低。

  3. AVL树的删除操作比较简单，只需要像插入一样旋转即可，在旋转过程中树的平衡性可以得到维护。

AVL树的缺点：

  1. AVL树每次插入或删除节点时需要进行旋转操作，这个操作比较耗时，因此在一些应用中不太适用。

  2. 在AVL树进行插入或删除操作时，为保持树的平衡需要不断进行旋转操作，在一些高并发环节和大数据量环境下，这可能会导致多余的写锁导致性能瓶颈。

  3. AVL树的旋转操作相对较多，因此在一些应用中可能会造成较大的空间浪费。

CodeCoffee:
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL树及其基本操作
爱技术的小白
06-27 438
本文是介绍AVL树及其插入操作。 1 AVL简介 AVL树是一种特殊的BST树，特殊的地方在于，左右子树高度的绝对值不超过一，所以在构建AVL树的时候，需要调整，以保证平衡。AVL树的作用与BST树是一样的，主要用于快速查找。 2 树的结构 class Tree<T extends Comparable<T>> { private static final int MAX_HEIGHT_DIFFERENCE = 1; private Node<T> roo
AVL树构建代码及其基本操作
GilgameshG的博客
10-23 1411
参考了很多代码后自己的总结.个人感觉AVL树的代码比huffman树的代码更难理解，有些地方刚开始看的时候觉得疑惑，为什么网络上的讲解能那么肯定就是那样，后来自己画了很多二叉树后发现，确实就是那样，所以就干脆把某些东西当规律记下来了。-_-发个无语的小表情 一.简单的AVL树自我理解 二叉平衡树呀，就是说每个节点的左子树和右子树的高度差最多为1，一个节点没有左右子树，高度为0，然后每有一层高度加
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
数据结构--AVL树与红黑树
平生的小铺子
08-26 1327
我们在上一章中初步认识到了set与map，了解了他们的使用，但是仅仅隐约的窥见了他们的底层实现，而这一章我们一起了解下他们的底层实现，以及数据结构较为复杂的部分，AVL树与红黑树 set与map的底层结构 前面对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是：其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关
AVL树图形化界面操作-MFC
09-17
在"AVL树图形化界面操作-MFC"项目中，开发者利用MFC的类库构建了一个图形用户界面（GUI），用户可以通过这个界面与AVL树进行交互。具体来说，用户可以执行以下操作： 1. **新建**：用户可以创建一个新的AVL树，这...
avl.rar_AVL树_树
09-23
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，...通过学习这些内容，我们可以掌握AVL树的基本原理，进一步提升在数据结构和算法领域的技能。
AVL.rar_AVL树_avl
09-19
AVL树的关键特性是它的平衡属性：任何节点的两个子树的高度差最多为1，这确保了AVL树在最坏情况下的操作效率都能保持在一个相对较高的水平。 AVL树的平衡因子是每个节点的左子树高度减去右子树高度的值。如果一个...
AVL.rar_AVL树
09-19
`AVL平衡二叉树.ppt`可能是演示文稿，用于教学或展示，包含AVL树的概念图、操作流程图以及可能的代码示例，帮助理解AVL树的工作机制。 学习AVL树不仅可以加深对数据结构的理解，还能提升解决复杂问题的能力。AVL树...
36. Adam 算法详解
qq_41238579的博客
07-10 953
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
函数模板与类模板
程序员_小兵
07-12 1541
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 670
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
【排序 - 堆排序】
2302_80393814的博客
07-10 539
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
最新发布
hanmo22357的博客
07-12 773
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
代码随想录算法训练营第33天
m0_62262158的博客
07-10 166
【代码】代码随想录算法训练营第33天。
力扣215 数组中第k大的数
东篱君的博客
07-10 292
算法：由于数组最大范围是10000，存在负数。申请一个20000的数组，将原数组的数作为新数组下标（+10000因为存在负数），然后从后往前减，求出第K大的数。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。本题主要考察各种排序算法，要求时间O（n），严格意义上说只有计数排序满足条件。给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树
wonderlandlja的博客
07-11 209
【代码】代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树。
SMU Summer 2024 Contest Round 2
FS_tar的博客
07-09 472
本来想直接暴力k的，0——6，3的六次方有点太大了，可以循环每个即可，一个比较简单的模拟。N个产品，每个产品在T【i】时间持续D【i】秒经过打印机，可以接受打印，打印是一瞬间的事但打印完需要冷却一秒。n个长度为l【i】的单词，每个单词间隔一空，行首不用间隔，给定最多m行，求窗口最小宽度。对着这题目和题解得有将近四小时吧，看的还是很懵而且对着答案一直在改，给我改麻木了已经。给定长度为n的字符串s，q个询问，求在l到r的范围内有多少组俩个连续字符。给出数字k，每9个循环，中间镂空，具体输出见示例。
最小二乘算法的解
xiaofeixia002X的博客
07-12 287
最小二乘法（Least Squares）是一种用于寻找线性回归模型的最佳拟合直线的标准方法。它通过最小化数据点与拟合直线之间的平方差来找到最佳拟合的线性模型。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值