JS数据结构5：树-自平衡二叉树

最新推荐文章于 2022-04-07 09:54:36 发布
最新推荐文章于 2022-04-07 09:54:36 发布
阅读量412 收藏 1
点赞数
分类专栏： JS数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44145258/article/details/106465552
版权

文章目录

概念

BST 存在一个问题：
取决于你添加的节点数，树的一条边可能会非常深；
也就是说，树的一条分支会有很多层，而其他的分支却只有几层，
这会造成很大的性能问题
所以需要平衡二叉搜索树来解决这个问题
在这里插入图片描述
平衡二叉树的概念

  • 在AVL 树中，需要对每个节点计算右子树高度（hr）和左子树高度（hl）之间的差值，该值（hr－hl）应为0、1 或 -1。
  • 如果结果不是这三个值之一，则需要平衡该AVL 树。
    这就是平衡因子的概念。
    在这里插入图片描述

AVL的实现

  • 我们可以扩展我们写的BST 类，只需要覆盖用来维持AVL 树平衡的方法，也就是insert、insertNode 和removeNode 方法。
  • 所有其他的BST 方法将会被AVLTree 类继承。

1 平衡因子的计算

const BalanceFactor = {
    UNBALANCED_RIGHT: 1,
    SLIGHTLY_UNBALANCED_RIGHT: 2,
    BALANCED: 3,
    SLIGHTLY_UNBALANCED_LEFT: 4,
    UNBALANCED_LEFT: 5
};

// 树的高度
getNodeHeight(node) {
    if (!node) {
        return -1;
    }
    return Math.max(this.getNodeHeight(node.left), this.getNodeHeight(node.right)) + 1;
}

// 两个树的高度差
getBalanceFactory(node) {
    let heightDifference = this.getNodeHeight(node.left) - this.getNodeHeight(node.right);
    switch (heightDifference) {
        case -2:    // 右边不平衡
            return BalanceFactory.UNBALANCE_RIGHT;
        case -1:    // 右边有点点不平衡
            return BalanceFactory.SLIGHTLY_UNBALANCE_RIGHT;
        case 0:    // 平衡
            return BalanceFactory.BALANCE;
        case 1:    // 左边有点点不平衡
            return BalanceFactory.SLIGHTLY_UNBALANCE_LEFT;
        case 2:    // 左边不平衡
            return BalanceFactory.UNBALANCE_LEFT;
    }
}

2 平衡操作

  • 左-左（LL）：向右的单旋转
  • 右-右（RR）：向左的单旋转
  • 左-右（LR）：向右的双旋转（先LL 旋转，再RR 旋转）
  • 右-左（RL）：向左的双旋转（先RR 旋转，再LL 旋转）

向右的单旋转LL

这种情况出现于节点的左侧子节点的高度大于右侧子节点的高度时，并且左侧子节点也是平衡或左侧较重的，这个时候需要左子树放在上面。者就是所谓的右单旋转
在这里插入图片描述
假设向AVL 树插入节点5，这会造成树失衡（节点50-Y 高度为+2），需要恢复树的平衡。

  1. 保存不平衡树node的左子树temp
  2. node左子树替换为temp的右子树
  3. temp的右子树替换为改变后的node树

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

    rotationLL(node) {
        let temp = node.left;
        node.left = temp.right;
        temp.right = node;
        return temp;
    }

在这里插入图片描述

RR:向左的单旋转

与LL情况相反。它出现于右侧子节点的高度大于左侧子节点的高度，并且右侧子节点也是平衡或右侧较重的

    rotationRR(node) {
        let temp = node.right;
        node.right = temp.left;
        temp.left = node;
        return temp;
    }

向右的双旋转LR：Left-Right

  • 这种情况出现于左侧子节点的高度大于右侧子节点的高度，并且左侧子节点右侧较重.
  • 简而言之，左子树重了，左子树中的右子树也重了
  • 在这种情况下，可以先对左侧子节点进行RR左旋转来修复，这样会形成LL的情况，然后再对不平衡的节点进行一个LL右旋转来修复

在这里插入图片描述

    rotationLR(node) {
        node.left = this.rotationRR(node.left);
        return this.rotationLL(node);
    }

向左的双旋转RL: Right-Left

  1. 先对右子树进行LL右旋，整个树形成RR条件
  2. 再对整个树RR左旋
    在这里插入图片描述
    rotationRL(node) {
        node.right = this.rotationLL(node.right);
        return this.rotationRR(node);
    }

3 插入结点

插入方法和bst是一样的，不过还需要讨论不平衡的情况

  1. 如果在向左侧子树插入节点后树不平衡了，我们需要比较是否插入的键小于左侧子节点的键。如果是，我们要进行LL 旋转。否则，要进行LR 旋转。
  2. 如果在向右侧子树插入节点后树不平衡了，我们需要比较是否插入的键小于右侧子节点的键。如果是，我们要进行RR 旋转。否则，要进行RL 旋转。
insert(key) {
    this.root = this.insertNode(this.root, key);
}
insertNode(node, key) {
    // 像在BST 树中一样插入节点
    if (node == null) {
        return new Node(key);
    } else if (this.compareFn(key, node.key) === Compare.LESS_THAN) {
        node.left = this.insertNode(node.left, key);
    } else if (this.compareFn(key, node.key) === Compare.BIGGER_THAN) {
        node.right = this.insertNode(node.right, key);
    } else {
        return node; // 重复的键
    }
    // 如果需要，将树进行平衡操作
    const balanceFactor = this.getBalanceFactor(node);
   	// 左不平衡
    if (balanceFactor === BalanceFactor.UNBALANCED_LEFT) {
    	// 判断是否存在LR情况
        if (this.compareFn(key, node.left.key) === Compare.LESS_THAN) {
            node = this.rotationLL(node);
        } else {
            return this.rotationLR(node);
        }
    }
    // 右不平衡
    if (balanceFactor === BalanceFactor.UNBALANCED_RIGHT) {
        if (this.compareFn(key, node.right.key) === Compare.BIGGER_THAN) {
            node = this.rotationRR(node);
        } else {
            return this.rotationRL(node);
        }
    }
    return node;
}

4 删除结点

removeNode(node, key) {
    node = super.removeNode(node, key);
    if (node == null) {
        return node; // null，不需要进行平衡
    }
    // 检测树是否平衡
    const balanceFactor = this.getBalanceFactor(node);
    // 左不平衡 
    if (balanceFactor === BalanceFactor.UNBALANCED_LEFT) {
        // 左子树状态
        const balanceFactorLeft = this.getBalanceFactor(node.left);
        // 如果是平衡（h = 0）或者有点不平衡(h = 1),LL
        if (balanceFactorLeft === BalanceFactor.BALANCED ||
            balanceFactorLeft === BalanceFactor.SLIGHTLY_UNBALANCED_LEFT) {
            return this.rotationLL(node);
        }
        // 如果不平衡（h = 2）LR
        if (balanceFactorLeft === BalanceFactor.SLIGHTLY_UNBALANCED_RIGHT) {
            return this.rotationLR(node.left);
        }
    }
    // 右不平衡
    if (balanceFactor === BalanceFactor.UNBALANCED_RIGHT) {
        // 右子树
        const balanceFactorRight = this.getBalanceFactor(node.right);
        if (balanceFactorRight === BalanceFactor.BALANCED ||
            balanceFactorRight === BalanceFactor.SLIGHTLY_UNBALANCED_RIGHT) {
            return this.rotationRR(node);
        }
        if (balanceFactorRight === BalanceFactor.SLIGHTLY_UNBALANCED_LEFT) {
            return this.rotationRL(node.right);
        }
    }
    return node;
}

完整代码

class Node {
    constructor(key) {
        this.key = key; //  节点值
        this.left = null; // 左侧子节点引用
        this.right = null; // 右侧子节点引用
    }
}

const Compare = {
    LESS_THAN: -1,
    BIGGER_THAN: 1
};

class BinarySearchTree {
    constructor() {
        this.root = null; //  Node 类型的根节点 默认就是null
    }

    compareFn(a, b) {
        if (a === b) { //
            return 0;
        }
        return a < b ? Compare.LESS_THAN : Compare.BIGGER_THAN; // 比较函数, a<b返回-1. 大于则返回正1
    }

    insert(key) {
        if (this.root == null) {
            this.root = new Node(key);
        } else {
            this.insertNode(this.root, key);
        }
    }

    insertNode(node, key) {
        if (this.compareFn(key, node.key) === Compare.LESS_THAN) {
            if (node.left == null) {
                node.left = new Node(key);
            } else {
                this.insertNode(node.left, key);
            }
        } else {
            if (node.right == null) {
                node.right = new Node(key);
            } else {
                this.insertNode(node.right, key);
            }
        }
    }

    inOrderTraverse(callback) {
        this.inOrderTraverseNode(this.root, callback);
    }

    inOrderTraverseNode(node, callback) {
        if (node != null) {
            this.inOrderTraverseNode(node.left, callback);
            callback(node.key);
            this.inOrderTraverseNode(node.right, callback);
        }
    }

    preOrderTraverse(callback) {
        this.preOrderTraverseNode(this.root, callback);
    }

    preOrderTraverseNode(node, callback) {
        if (node != null) {
            callback(node.key);
            this.preOrderTraverseNode(node.left, callback);
            this.preOrderTraverseNode(node.right, callback);
        }
    }

    postOrderTraverse(callback) {
        this.postOrderTraverseNode(this.root, callback);
    }

    postOrderTraverseNode(node, callback) {
        if (node != null) {
            this.postOrderTraverseNode(node.left, callback);
            this.postOrderTraverseNode(node.right, callback);
            callback(node.key);
        }
    }

    min() {
        return this.minNode(this.root);
    }

    minNode(node) {
        let current = node;
        while (current != null && current.left != null) {
            current = current.left;
        }
        return current;
    }

    max() {
        return this.maxNode(this.root);
    }

    maxNode(node) {
        let current = node;
        while (current != null && current.right != null) {
            current = current.right;
        }
        return current;
    }

    search(key) {
        return this.searchNode(this.root, key);
    }

    searchNode(node, key) {
        if (node == null) {
            return false;
        }
        if (this.compareFn(key, node.key) === Compare.LESS_THAN) {
            return this.searchNode(node.left, key);
        } else if (
            this.compareFn(key, node.key) === Compare.BIGGER_THAN
        ) {
            return this.searchNode(node.right, key);
        } else {
            return true;
        }
    }

    remove(key) {
        this.root = this.removeNode(this.root, key);
    }

    removeNode(node, key) {
        if (node == null) {
            return null;
        }
        if (this.compareFn(key, node.key) === Compare.LESS_THAN) {
            node.left = this.removeNode(node.left, key);
            return node;
        } else if (
            this.compareFn(key, node.key) === Compare.BIGGER_THAN
        ) {
            node.right = this.removeNode(node.right, key);
            return node;
        } else {
            // 键等于node.key
            // 第一种情况
            if (node.left == null && node.right == null) {
                node = null;
                return node;
            }
            // 第二种情况
            if (node.left == null) {
                node = node.right;
                return node;
            } else if (node.right == null) {
                node = node.left;
                return node;
            }
            // 第三种情况
            const aux = this.minNode(node.right);
            node.key = aux.key;
            node.right = this.removeNode(node.right, aux.key);
            return node;
        }
    }
}

const BalanceFactor = {
    UNBALANCED_RIGHT: 1,
    SLIGHTLY_UNBALANCED_RIGHT: 2,
    BALANCED: 3,
    SLIGHTLY_UNBALANCED_LEFT: 4,
    UNBALANCED_LEFT: 5
};



class AVLTree extends BinarySearchTree {
    constructor() {
        super();
        this.root = null;
    }
    getNodeHeight(node) {
        if (node == null) {
            return -1;
        }
        return Math.max(
            this.getNodeHeight(node.left), this.getNodeHeight(node.right)
        ) + 1;
    }
    getBalanceFactor(node) {
        const heightDifference = this.getNodeHeight(node.left) -
            this.getNodeHeight(node.right);
        switch (heightDifference) {
            case -2:
                return BalanceFactor.UNBALANCED_RIGHT;
            case -1:
                return BalanceFactor.SLIGHTLY_UNBALANCED_RIGHT;
            case 1:
                return BalanceFactor.SLIGHTLY_UNBALANCED_LEFT;
            case 2:
                return BalanceFactor.UNBALANCED_LEFT;
            default:
                return BalanceFactor.BALANCED;
        }
    }
    rotationLL(node) {
        const tmp = node.left;
        node.left = tmp.right;
        tmp.right = node;
        return tmp;
    }
    rotationRR(node) {
        const tmp = node.right;
        node.right = tmp.left;
        tmp.left = node;
        return tmp;
    }
    rotationLR(node) {
        node.left = this.rotationRR(node.left);
        return this.rotationLL(node);
    }
    rotationRL(node) {
        node.right = this.rotationLL(node.right);
        return this.rotationRR(node);
    }
    insert(key) {
        this.root = this.insertNode(this.root, key);
    }
    insertNode(node, key) {
        // 像在BST 树中一样插入节点
        if (node == null) {
            return new Node(key);
        } else if (this.compareFn(key, node.key) === Compare.LESS_THAN) {
            node.left = this.insertNode(node.left, key);
        } else if (this.compareFn(key, node.key) === Compare.BIGGER_THAN) {
            node.right = this.insertNode(node.right, key);
        } else {
            return node; // 重复的键
        }
        // 如果需要，将树进行平衡操作
        const balanceFactor = this.getBalanceFactor(node);
        if (balanceFactor === BalanceFactor.UNBALANCED_LEFT) {
            if (this.compareFn(key, node.left.key) === Compare.LESS_THAN) {
                node = this.rotationLL(node);
            } else {
                return this.rotationLR(node);
            }
        }
        if (balanceFactor === BalanceFactor.UNBALANCED_RIGHT) {
            if (
                this.compareFn(key, node.right.key) === Compare.BIGGER_THAN
            ) {
                node = this.rotationRR(node);
            } else {
                return this.rotationRL(node);
            }
        }
        return node;
    }
    removeNode(node, key) {
        node = super.removeNode(node, key);
        if (node == null) {
            return node; // null，不需要进行平衡
        }
        // 检测树是否平衡
        const balanceFactor = this.getBalanceFactor(node);
        // 左不平衡 
        if (balanceFactor === BalanceFactor.UNBALANCED_LEFT) {
            // 左子树状态
            const balanceFactorLeft = this.getBalanceFactor(node.left);
            // 如果是平衡（h = 0）或者有点不平衡(h = 1),LL
            if (balanceFactorLeft === BalanceFactor.BALANCED ||
                balanceFactorLeft === BalanceFactor.SLIGHTLY_UNBALANCED_LEFT) {
                return this.rotationLL(node);
            }
            // 如果不平衡（h = 2）LR
            if (balanceFactorLeft === BalanceFactor.SLIGHTLY_UNBALANCED_RIGHT) {
                return this.rotationLR(node.left);
            }
        }
        // 右不平衡
        if (balanceFactor === BalanceFactor.UNBALANCED_RIGHT) {
            // 右子树
            const balanceFactorRight = this.getBalanceFactor(node.right);
            if (balanceFactorRight === BalanceFactor.BALANCED ||
                balanceFactorRight === BalanceFactor.SLIGHTLY_UNBALANCED_RIGHT) {
                return this.rotationRR(node);
            }
            if (balanceFactorRight === BalanceFactor.SLIGHTLY_UNBALANCED_LEFT) {
                return this.rotationRL(node.right);
            }
        }
        return node;
    }
}

let avl = new AVLTree();
avl.insert(70);
avl.insert(50);
avl.insert(80);
avl.insert(72);
avl.insert(90);
avl.insert(75);
avl.remove(70);
avl.remove(50);
console.log(avl);
斜光
关注
专栏目录
js实现自平衡树 AVL tree
nidaye666666的博客
02-26 402
AVL tree1. 笔记插入节点的特殊情况删除节点的特殊情况2. 所有代码2.1 自平衡树2.2 二叉搜索树 1. 笔记 节点高度：Math.max(左节点高度, 右节点高度)+1 平衡因子：左节点高度 - 右节点高度，节点内数字表示当前节点的平衡因子。 平衡操作共有四种情况。 1. 向右的单旋转 LL: 当前节点的左节点比右节点重，当前节点的左节点的左节点比右节点重。 2. 向左的单旋转 R...
数据结构---自平衡二叉树AVL
inferno_devil的博客
05-23 292
1.01 AVL树 名字缘由：G.M.Adelson-Velsky和E.M.Landis 。是一种最早的自平衡二分搜索树结构 。 AVL树既是平衡二叉树。AVL树的定义首先要求该树是二叉查找树（满足排序规则），并在此基础上增加了每个节点的平衡因子的定义，一个节点的平衡因子是该节点的左子树树高减去右子树树高的值。 平衡因子BF：该节点的左子树的深度减去它的右子树深度。（平衡二叉树上的所有节...
JS 实现自平衡二叉查找树（AVL树）
三月的船长
09-16 357
该树的代码基本上是从我上篇文章 JS 实现二叉查找树 加入平衡因子，高度，旋转等 AVL 树的概念升级而来，写的过程中发现，思想就一个递归，细节就是递归处理操作的时候严不严谨，难点就是概念的理解的准不准确。
平衡二叉树
qq550764107的专栏
04-27 573
旋转     节点再怎么失衡都逃不过4种情况，下面我们一一来看一下。 ① 左左情况（左子树的左边节点） 我们看到，在向树中追加“节点1”的时候，根据定义我们知道这样会导致了“节点3"失衡，满足“左左情况“，可以这样想，把这 棵树比作齿轮，我们在“节点5”处把齿轮往下拉一个位置，也就变成了后面这样“平衡”的形式，如果用动画解释就最好理解了。 1
python 判断平衡二叉树后序遍历_判断平衡二叉树——Python
weixin_39767887的博客
12-11 121
给定一棵二叉树，判断它是否为平衡二叉树。平衡二叉树的定义是：如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。拿到二叉树的题目，一般的解题思路都可以先从左右子树递归求解。如果左子树不满足平衡或右子树不满足平衡，那么就判断它不是平衡的。具体看代码：# Definition for a binary tree node.# class TreeNode:# def ...
数据结构----平衡二叉树的JS实现
from_the_star的博客
05-16 319
在高效的检索方法中， 二分检索法具有最高的查找效率，但是它只适合于顺序存储结构，这样对于数据的操作和删除操作带来不便。 二叉排序树不仅有二分检索的效率，同时保持数据的动态性。但是当二叉排序树只有左子树或者右子树，二叉排序树就退化成了单链表，具有较低的检索效率。 平衡二叉树就可以解决这种问题。平衡二叉树又称为AVL树，它或是一颗空树，或是具有以下性质的二叉树： 它的左右子树都是平衡二叉树，且左子树和右子树的高度之差绝对值不超过1。 平衡二叉树的调整 插入时通过对二叉树的调整可以保持这棵树为平衡二叉树。只有这么
(数据结构)树(二)平衡二叉树
Gavin's Blog
06-30 546
我们知道，对于一般的二叉搜索树（Binary Search Tree），其期望高度（即为一棵平衡树时）为log2nlog_{2}nlog2​n，其各操作的时间复杂度O(log2nlog_{2}nlog2​n)同时也由此而决定。但是，在某些极端的情况下（如在插入的序列是有序的时），二叉搜索树将退化成近似链或链，此时，其操作的时间复杂度将退化成线性的，即O(n)。我们可以通过随机化建立二叉搜索树来尽量...
js代码-13.2 平衡二叉树构造
07-14
5. **JavaScript实现**：在JavaScript中实现平衡二叉树，需要创建表示节点的对象，包含值、左子节点和右子节点属性。同时，需要编写插入、查找和删除方法，以及平衡调整的逻辑。平衡调整通常在插入新节点后进行，...
BinaryTree:实现自平衡二叉树
05-03
总的来说，自平衡二叉树是数据结构中非常重要的一部分，它们在数据库索引、文件系统、编译器符号表等多个领域都有广泛应用。理解并掌握AVL树和红黑树的实现，将有助于提升你在IT领域的专业技能。
js代码-200609-平衡二叉树
07-16
在JavaScript中实现平衡二叉树，我们可以选择AVL树或红黑树等经典的数据结构。 在`main.js`文件中，我们可能看到了平衡二叉树的JavaScript实现。通常，平衡二叉树的实现会包括以下几个关键部分： 1. **节点定义**...
JavaScript数据结构与算法之二叉树插入节点、生成二叉树示例
10-17
二叉树是计算机科学中的一种重要数据结构，它是由节点（也称为顶点）组成，每个节点最多有两个子节点，通常分别...对于想要深入学习JavaScript数据结构和算法的人来说，掌握二叉搜索树的原理和实现是非常重要的一步。
java avl自平衡二叉树_『数据结构与算法』AVL树（平衡二叉树）
weixin_33700405的博客
02-26 122
GitHub源码分享主页地址：/gozhuyinglong.github.io源码分享：github.com/gozhuyinglong/blog-demos1. AVL树AVL(Adelson-Velskii 和 Landis)树是带有平衡条件的[二叉查找树]，又叫做平衡二叉树。在AVL树中任何节点的两个子树高度差最多为1，所以它又被称为高度平衡树。如下图中可以清晰的看出，左边的树其根节点左子树...
Javascript之数据结构与算法的自平衡二叉搜索树（AVL）实现
wushichao0325的博客
01-09 322
Javascript之数据结构与算法的自平衡二叉搜索树（AVL）实现简介代码实现 简介 AVL树是一种自平衡树。添加或移除节点时， AVL树会尝试自平衡。任意一个节点（不论深 度）的左子树和右子树高度最多相差1。添加或移除节点时， AVL树会尽可能尝试转换为完全树。 平衡因子是在AVL树中，需要对每个节点计算右子树高度（ hr）和左子树高度（ hl）的差值，该值（ hr－ hl）应为0、1或-1。...
自平衡二叉树
chenkui199的博客
04-07 126
package demo; import java.util.LinkedList; import java.util.prefs.BackingStoreException; import org.w3c.dom.Node; /** * 自平衡二叉树 * * @author Administrator * * @param <K> * @param <V> */ public class BSTAvl<K extends Comparable<K.
自平衡二叉树(AVL树)
lee_nacl的博客
01-30 2121
概述 它是一棵二叉排序树，它的左右两个子树的高度差（平衡因子）的绝对值不超过1，并且左右两棵子树都是一棵平衡二叉树 目的：使得树的高度最低，因为树查找的效率决定树的高度 自平衡二叉树的调整 如果A是一棵平衡二叉树，如果新插入一个元素，会有两个结果 平衡没有被打破，不用调整； 平衡被打破，需要调整 调整规则：根据插入节点与失衡节点的位置关系来划分 LL旋转 插入节点在失衡节点的左子树的左边只需要经过一次左旋即可达到平衡 RR旋转 插入节点在失衡节点的右子树的右边只需要经过一..
自平衡二叉树（Self-balancing binary search tree）
cristianoxm的博客
04-09 3376
排序二叉树有以下缺点： 同样的关键字集合有可能导致不同的树结构索引，如下图的右图所示，此时他的搜索性能已经是线性的了，为了解决这种"树一边倒的现象"，自平衡二叉树就被提出来了。平衡二叉树的目的是为了减少二叉查找树层次，提高查找速度。 平衡二叉树 定义：平衡二叉树或为空树,又被称为AVL树（有别于AVL算法）或为如下性质的二叉排序树: （1）左右子树深度之差的绝对值不超过1; （2）左右子树仍...
平衡二叉树算法分析
JAVA-Miner
12-11 1833
1、平衡二叉树定义：  平衡二叉树（Balanced Binary Tree或Height-Balanced Tree）又称AVL树。它或者是一颗空树，或者是具有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。若将二叉树上结点的平衡因子bf(balance factor)定义为该结点的左子树的深度减去右子树的深度，则平衡二叉树上所有结点的平衡因
树（三）——自平衡二叉树（AVL）
weixin_30301449的博客
09-12 187
简介 自平衡二叉树（AVL）属于二叉平衡树的一类，此类树主要完成一个从键到值的查找过程，即字典（或映射），它维护树高度的方式与其他数据结构不同。 自平衡规则： AVL树的左、右子树都是AVL树 左、右子树的高度差不超过1 在数据结构中，最常见的数据间关系的抽象就是集合（Collection）和字典（Dictionary）。 集合就是线性表（元素允许重复），而字典是一种非多键映射关系（键不允许重...
数据结构C版：经典严蔚敏版学习资源大全
而树形结构如二叉树和平衡树（如AVL树、红黑树）在文件系统、数据库索引等方面有广泛应用。图结构则在路由算法、社交网络分析等领域发挥重要作用。 在C语言实现数据结构时，需要关注内存管理、指针操作以及算法效率...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值