数据结构——平衡二叉树（AVL树）

已于 2022-01-21 19:55:10 修改
阅读量501 收藏
点赞数
分类专栏： # 数据结构 文章标签： 数据结构 二叉树 二分查找 算法 java
于 2022-01-07 10:32:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35258036/article/details/122359221
版权

平衡二叉树

平衡二叉树

当且仅当任何节点的两棵子树的高度差不大于1的自平衡的二叉搜索树

原理

  • 平衡因子：某节点的左子树与右子树的高度差

  • 失衡节点：在插入/删除的结点向上查找，第一个平衡因子等于2的结点称为失衡节点

  • 通过旋转失衡节点，减少高度，将树重新调整为平衡二叉树

理解重点

平衡二叉树的增删和二叉搜索树的增删是一样的

不同在于平衡二叉树增删后可能需要旋转调整

不要边增删边旋转，这样会难以理解（增删后再旋转）

平衡高度代码

balanceHeight()调整失衡节点，失衡节点的平衡因子等于2，故可分为4种情况

增加操作删除操作旋转操作
失衡节点的右节点的右子树增加节点删除左节点且失衡节点的右节点有(左)右子树对失衡节点左旋
失衡节点的右节点的左子树增加节点删除左节点且失衡节点的右节点仅有左子树对失衡节点的右节点右旋、对失衡节点左旋
失衡节点的左节点的左子树增加节点删除右节点且失衡节点的左节点有左(右)子树对失衡节点右旋
失衡节点的左节点的右子树增加节点删除右节点且失衡节点的左节点仅有右子树对失衡节点的左节点左旋、对失衡节点右旋
  • 失衡节点的平衡因子等于-2说明增加到右节点，再判断是增加到左子树还是右子树
  • 失衡节点的平衡因子等于2说明增加到左节点，再判断是增加左子树还是右子树
  • 删除节点相当于另一边增加节点（调整代码是一样的）
private void balanceHeight(TreeNode unBalancedNode) {
    if (unBalancedNode == null) {
        return;
    }
    if (getBalanceFactor(unBalancedNode) == -2) { 
        if (getBalanceFactor(unBalancedNode.rightChild) == 1) { 
            rightRotate(unBalancedNode.rightChild);
        }
        leftRotate(unBalancedNode);
    } else if (getBalanceFactor(unBalancedNode) == 2) {
        if (getBalanceFactor(unBalancedNode.leftChild) == -1) { 
            leftRotate(unBalancedNode.leftChild);
        }
        rightRotate(unBalancedNode);
    }
}

private void leftRotate(TreeNode unBalancedNode) {
    TreeNode unBalancedNodeParent = getParent(unBalancedNode);
    TreeNode temp = unBalancedNode.rightChild;
    if (unBalancedNodeParent == null) {  
        root = temp;
    } else {
        unBalancedNodeParent.leftChild = temp;     
    }
    unBalancedNode.rightChild = temp.leftChild; 
    temp.leftChild = unBalancedNode;  
}

private void rightRotate(TreeNode unBalancedNode) {
    TreeNode unBalancedNodeParent = getParent(unBalancedNode);
    TreeNode temp = unBalancedNode.leftChild;
    if (unBalancedNodeParent == null) {
        root = temp;
    } else {
        unBalancedNodeParent.rightChild = temp;
    }
    unBalancedNode.leftChild = temp.rightChild;
    temp.rightChild = unBalancedNode;
}

leftRotate()实现指定节点的左旋，具体为（右旋对称同理）：

  • 获取其父节点和其右节点
  • 若其父节点为空，则其右节点称为新父节点，否则让其父节点指向其右节点（即断开指定节点和其父节点）
  • 指定节点的右节点指向其右节点的左节点（即断开指定节点和其右节点，拿到其右节点的左节点）
  • 其右节点的左节点指向该节点（即连回指定节点，右节点变成指定节点的父节点）

左旋示意图
请添加图片描述
右旋示意图
请添加图片描述

代码实现

  • innerMidOrderTraversal()：中序遍历验证旋转结果
  • innerAdd()：从二叉搜索树复制过来的代码，返回增加的节点
  • innerSearch()、MinNode()、getSuc()、InnerRemove()：从二叉搜索树复制过来的代码，为了找到待删除节点和链接后序节点，返回删除的节点
  • getTreeHeight()、getBalanceFactor()、getUnbalancedNode()：获取节点高度、平衡因子、失衡节点
  • add()、remove()：先进行二叉搜索树的增删，返回增删节点，找到对应的失衡节点，调用balanceHeight()
class BalancedBinaryTree {

    private class TreeNode {

        int value;
        TreeNode leftChild;
        TreeNode rightChild;

        TreeNode(int value) {
            this.value = value;
        }
    }

    private TreeNode root;

    private void innerMidOrderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        innerMidOrderTraversal(root.leftChild);
        System.out.print(root.value + " ");
        innerMidOrderTraversal(root.rightChild);
    }

    private void leftRotate(TreeNode unBalancedNode) {
        TreeNode unBalancedNodeParent = getParent(unBalancedNode);
        TreeNode temp = unBalancedNode.rightChild;
        if (unBalancedNodeParent == null) {                 //若失衡节点为根节点，则失衡节点的右节点为新根节点
            root = temp;
        } else {
            unBalancedNodeParent.leftChild = temp;          //失衡节点的父节点指向其右节点
        }
        unBalancedNode.rightChild = temp.leftChild;     //失衡节点的右节点指向其右节点的左节点
        temp.leftChild = unBalancedNode;                //连回失衡节点
    }

    private void rightRotate(TreeNode unBalancedNode) {
        TreeNode unBalancedNodeParent = getParent(unBalancedNode);
        TreeNode temp = unBalancedNode.leftChild;
        if (unBalancedNodeParent == null) {
            root = temp;
        } else {
            unBalancedNodeParent.rightChild = temp;
        }
        unBalancedNode.leftChild = temp.rightChild;
        temp.rightChild = unBalancedNode;
    }

    private int getTreeHeight(TreeNode node) {
        if (node == null) {
            return 0;
        }
        int leftDepth = getTreeHeight(node.leftChild) + 1;
        int rightDepth = getTreeHeight(node.rightChild) + 1;
        return Math.max(leftDepth, rightDepth);
    }

    private int getBalanceFactor(TreeNode node) {
        return getTreeHeight(node.leftChild) - getTreeHeight(node.rightChild);
    }

    private TreeNode getUnbalancedNode(TreeNode node) {
        TreeNode parent = getParent(node);
        while (parent != null) {
            if (Math.abs(getBalanceFactor(parent)) > 1) {	// ==2
                return parent;
            }
            parent = getParent(parent);
        }
        return null;
    }

    private TreeNode getParent(TreeNode node) {
        if (root == node) {
            return null;
        }
        if (node == null) {
            return null;
        }
        TreeNode current = root;
        TreeNode parent = null;
        while (current != null) {
            if (node.value < current.value) {
                parent = current;
                current = current.leftChild;
            } else if (node.value > current.value) {
                parent = current;
                current = current.rightChild;
            } else {
                return parent;
            }
        }
        return parent;
    }

    private void balanceHeight(TreeNode unBalancedNode) {
        if (unBalancedNode == null) {
            return;
        }
        System.out.print("旋转前 ——> 中序遍历：");
        innerMidOrderTraversal(root);
        System.out.println();

        if (getBalanceFactor(unBalancedNode) == -2) {   //删除左节点 == 右节点添加
            if (getBalanceFactor(unBalancedNode.rightChild) == 1) {     //右节点的左子树添加
                System.out.println("即将右旋");
                rightRotate(unBalancedNode.rightChild);
            }
            System.out.println("即将左旋");
            leftRotate(unBalancedNode);
        } else if (getBalanceFactor(unBalancedNode) == 2) {     //删除右节点 == 左节点添加
            if (getBalanceFactor(unBalancedNode.leftChild) == -1) {     //左节点的右子树添加
                System.out.println("即将左旋");
                leftRotate(unBalancedNode.leftChild);
            }
            System.out.println("即将右旋");
            rightRotate(unBalancedNode);
        }

        System.out.print("旋转后 ——> 中序遍历：");
        innerMidOrderTraversal(root);
        System.out.println();
    }

    public void add(int value) {
        TreeNode addNode = innerAdd(value);
        System.out.print("添加节点为: " + addNode.value);

        TreeNode unBalancedNode = getUnbalancedNode(addNode);
        System.out.println(" ——> 失衡节点为: " + (unBalancedNode == null ? "null" : unBalancedNode.value));

        balanceHeight(unBalancedNode);
    }

    private TreeNode innerAdd(int value) {
        if (root == null) {
            root = new TreeNode(value);
            return root;
        } else {
            TreeNode parent;
            TreeNode current = root;
            while (true) {
                parent = current;
                if (value < current.value) {
                    current = current.leftChild;
                    if (current == null) {
                        parent.leftChild = new TreeNode(value);
                        return parent.leftChild;
                    }
                } else {
                    current = current.rightChild;
                    if (current == null) {
                        parent.rightChild = new TreeNode(value);
                        return parent.rightChild;
                    }
                }
            }
        }
    }

    private TreeNode innerSearch(TreeNode root, int value) {
        if (root == null) {
            return null;
        }
        if (value < root.value) {
            return innerSearch(root.leftChild, value);
        } else if (value > root.value) {
            return innerSearch(root.rightChild, value);
        } else {
            return root;
        }
    }

    private TreeNode MinNode(TreeNode node) {
        if (node == null) {
            return null;
        }
        TreeNode current = node;
        while (current.leftChild != null) {
            current = current.leftChild;
        }
        return current;
    }

    private TreeNode getSuc(TreeNode node) {
        if (node.rightChild != null) {
            return MinNode(node.rightChild);
        } else {
            TreeNode parent = getParent(node);
            if (parent == null) {
                return null;
            }
            if (node == parent.leftChild) {
                return parent;
            } else {    //node == parent.rightChild
                while (parent != null) {
                    if (parent.value > node.value) {
                        break;
                    }
                    parent = getParent(node);
                }
                return parent;
            }
        }
    }

    public void remove(int value) {
        TreeNode delNode = InnerRemove(value);
        System.out.print("删除节点为: " + delNode.value);

        TreeNode unBalancedNode = getUnbalancedNode(delNode);
        System.out.println(" ——> 失衡节点为: " + (unBalancedNode == null ? "null" : unBalancedNode.value));

        balanceHeight(unBalancedNode);
    }

    private TreeNode InnerRemove(int value) {
        TreeNode delNode = innerSearch(root, value);
        TreeNode parent = getParent(delNode);
        if (delNode.leftChild == null && delNode.rightChild == null) {  //删除的节点无左右节点，则断开父节点和它的连接（若是根节点则置空）
            if (parent == null) {   //delNode = root
                root = null;
            } else {
                if (delNode == parent.leftChild) {
                    parent.leftChild = null;
                } else {
                    parent.rightChild = null;
                }
            }
        } else if (delNode.leftChild == null && delNode.rightChild != null) { //删除的节点有右节点，则让其右节点连上父节点（若是根节点，则右节点成为新根节点）
            if (parent == null) {   //delNode = root
                root = delNode.rightChild;
            } else {
                if (delNode == parent.leftChild) {
                    parent.leftChild = delNode.rightChild;
                } else {
                    parent.rightChild = delNode.rightChild;
                }
            }
        } else if (delNode.leftChild != null && delNode.rightChild == null) { //删除的节点有左节点，则让其左节点连上父节点（若是根节点，则左节点成为新根节点）
            if (parent == null) {   //delNode = root
                root = delNode.leftChild;
            } else {
                if (delNode == parent.leftChild) {
                    parent.leftChild = delNode.leftChild;
                } else {
                    parent.rightChild = delNode.leftChild;
                }
            }
        } else { //删除的节点左右节点都有
            if (parent == null) {   //delNode = root，则左右节点任意一个都可成为新根节点
                root = delNode.leftChild;
                //root = delNode.rightChild;
            } else {
                TreeNode successor = getSuc(delNode);
                TreeNode successorParent = getParent(successor);
                if (successorParent == delNode) {   //若后继节点是删除节点的右节点
                    parent.rightChild = successor;
                    successor.leftChild = delNode.leftChild;
                    delNode.leftChild = null;
                } else {                  //若后继节点是删除节点的右子树的左节点
                    successorParent.leftChild = successor.rightChild;   //断开successor
                    successor.rightChild = null;

                    parent.leftChild = successor;               //del父节点指向successor，即断开del
                    successor.rightChild = delNode.rightChild;  //successor连接delNode右子树
                    delNode.rightChild = null;                  //断开delNode右子树

                    successor.leftChild = delNode.leftChild;    //successor连接delNode左子树
                    delNode.leftChild = null;                   //断开delNode左子树
                }
            }
        }
        return delNode;
    }
}

代码测试

这里不讲解平衡二叉树的增删步骤代码，如果不知道请看二叉搜索树

增加测试

失衡节点的右节点的右子树增加节点

BalancedBinaryTree balancedBinaryTree = new BalancedBinaryTree();
balancedBinaryTree.add(5);
balancedBinaryTree.add(3);
balancedBinaryTree.add(8);
balancedBinaryTree.add(7);
balancedBinaryTree.add(9);
balancedBinaryTree.add(10);

打印如下

添加节点为: 5 ——> 失衡节点为: null
添加节点为: 3 ——> 失衡节点为: null
添加节点为: 8 ——> 失衡节点为: null
添加节点为: 7 ——> 失衡节点为: null
添加节点为: 9 ——> 失衡节点为: null
添加节点为: 10 ——> 失衡节点为: 5
旋转前 ——> 中序遍历：3 5 7 8 9 10 
即将左旋
旋转后 ——> 中序遍历：3 5 7 8 9 10

失衡节点的右节点的左子树增加节点

BalancedBinaryTree balancedBinaryTree = new BalancedBinaryTree();
balancedBinaryTree.add(5);
balancedBinaryTree.add(3);
balancedBinaryTree.add(8);
balancedBinaryTree.add(7);
balancedBinaryTree.add(9);
balancedBinaryTree.add(6);

打印如下

添加节点为: 5 ——> 失衡节点为: null
添加节点为: 3 ——> 失衡节点为: null
添加节点为: 8 ——> 失衡节点为: null
添加节点为: 7 ——> 失衡节点为: null
添加节点为: 9 ——> 失衡节点为: null
添加节点为: 6 ——> 失衡节点为: 5
旋转前 ——> 中序遍历：3 5 6 7 8 9 
即将右旋
即将左旋
旋转后 ——> 中序遍历：3 5 6 7 8 9

失衡节点的左节点的左子树增加节点

BalancedBinaryTree balancedBinaryTree = new BalancedBinaryTree();
balancedBinaryTree.add(8);
balancedBinaryTree.add(5);
balancedBinaryTree.add(9);
balancedBinaryTree.add(3);
balancedBinaryTree.add(7);
balancedBinaryTree.add(2);

打印如下

添加节点为: 8 ——> 失衡节点为: null
添加节点为: 5 ——> 失衡节点为: null
添加节点为: 9 ——> 失衡节点为: null
添加节点为: 3 ——> 失衡节点为: null
添加节点为: 7 ——> 失衡节点为: null
添加节点为: 2 ——> 失衡节点为: 8
旋转前 ——> 中序遍历：2 3 5 7 8 9 
即将右旋
旋转后 ——> 中序遍历：2 3 5 7 8 9

失衡节点的左节点的右子树增加节点

BalancedBinaryTree balancedBinaryTree = new BalancedBinaryTree();
balancedBinaryTree.add(8);
balancedBinaryTree.add(5);
balancedBinaryTree.add(9);
balancedBinaryTree.add(3);
balancedBinaryTree.add(7);
balancedBinaryTree.add(6);

打印如下

添加节点为: 8 ——> 失衡节点为: null
添加节点为: 5 ——> 失衡节点为: null
添加节点为: 9 ——> 失衡节点为: null
添加节点为: 3 ——> 失衡节点为: null
添加节点为: 7 ——> 失衡节点为: null
添加节点为: 6 ——> 失衡节点为: 8
旋转前 ——> 中序遍历：3 5 6 7 8 9 
即将左旋
即将右旋
旋转后 ——> 中序遍历：3 5 6 7 8 9

删除测试

删除左节点且失衡节点的右节点有(左)右子树

BalancedBinaryTree balancedBinaryTree = new BalancedBinaryTree();
balancedBinaryTree.add(5);
balancedBinaryTree.add(3);
balancedBinaryTree.add(8);
balancedBinaryTree.add(9);
//balancedBinaryTree.add(7);
balancedBinaryTree.remove(3);

打印如下

添加节点为: 5 ——> 失衡节点为: null
添加节点为: 3 ——> 失衡节点为: null
添加节点为: 8 ——> 失衡节点为: null
添加节点为: 9 ——> 失衡节点为: null
删除节点为: 3 ——> 失衡节点为: 5
旋转前 ——> 中序遍历：5 8 9 
即将左旋
旋转后 ——> 中序遍历：5 8 9

删除左节点且失衡节点的右节点仅有左子树

BalancedBinaryTree balancedBinaryTree = new BalancedBinaryTree();
balancedBinaryTree.add(5);
balancedBinaryTree.add(3);
balancedBinaryTree.add(8);
balancedBinaryTree.add(7);
balancedBinaryTree.remove(3);

打印如下

添加节点为: 5 ——> 失衡节点为: null
添加节点为: 3 ——> 失衡节点为: null
添加节点为: 8 ——> 失衡节点为: null
添加节点为: 7 ——> 失衡节点为: null
删除节点为: 3 ——> 失衡节点为: 5
旋转前 ——> 中序遍历：5 7 8 
即将右旋
即将左旋
旋转后 ——> 中序遍历：5 7 8

删除右节点且失衡节点的左节点有左(右)子树

BalancedBinaryTree balancedBinaryTree = new BalancedBinaryTree();
balancedBinaryTree.add(5);
balancedBinaryTree.add(3);
balancedBinaryTree.add(6);
balancedBinaryTree.add(2);
//balancedBinaryTree.add(4);
balancedBinaryTree.remove(6);

打印如下

添加节点为: 5 ——> 失衡节点为: null
添加节点为: 3 ——> 失衡节点为: null
添加节点为: 6 ——> 失衡节点为: null
添加节点为: 2 ——> 失衡节点为: null
删除节点为: 6 ——> 失衡节点为: 5
旋转前 ——> 中序遍历：2 3 5 
即将右旋
旋转后 ——> 中序遍历：2 3 5

删除右节点且失衡节点的左节点仅有右子树

BalancedBinaryTree balancedBinaryTree = new BalancedBinaryTree();
balancedBinaryTree.add(5);
balancedBinaryTree.add(3);
balancedBinaryTree.add(6);
balancedBinaryTree.add(4);
balancedBinaryTree.remove(6);

打印如下

添加节点为: 5 ——> 失衡节点为: null
添加节点为: 3 ——> 失衡节点为: null
添加节点为: 6 ——> 失衡节点为: null
添加节点为: 4 ——> 失衡节点为: null
删除节点为: 6 ——> 失衡节点为: 5
旋转前 ——> 中序遍历：3 4 5 
即将左旋
即将右旋
旋转后 ——> 中序遍历：3 4 5
松仔log
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】——平衡二叉树（AVL树）
qq_43412060的博客
02-19 164
上一篇文章我们讲述了二叉排序树，然而当我们遇到特殊情况，如a[10] ={3,2,1,4,5,6,7,10,9,8}的情况时完全符合二叉树的定义，但是对这样高度达到8的二叉树老说是非常不利的，所以我们对此引入了一个新的概念——平衡二叉树~ 一、什么是平衡二叉树 是一种高度平衡的二叉排序树，其中每一个结点的左子树和右子树的高度差至多等于1 。将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子B...
数据结构-平衡二叉树（AVL Tree）
蜗牛君的奋斗史
05-15 6893
在 数据结构-二叉树(binary tree)-二叉查找树(binary search tree) 的最后面，提到过在二叉树中增加或者删除节点，可能导致树的左右子树高度相差很多，即导致树不平衡。为了解决这个问题，规定在插入或者删除节点的时候，必须保证每一个节点的左右子树的高度差的绝对值不超过1，| height(left) - height(right) | <= 1。这样的二叉树称为平衡二叉树
Java数据结构——平衡二叉树(AVL树)
m0_62969222的博客
05-31 3220
AVL树的引入 搜索二叉树有着极高的搜索效率，但是搜索二叉树会出现以下极端情况： 这样的二叉树搜索效率甚至比链表还低。在搜索二叉树基础上出现的平衡二叉树(AVL树)就解决了这样的问题。当平衡二叉树(AVL树)的某个节点左右子树高度差的绝对值大于1时，就会通过旋转操作减小它们的高度差。 基本概念 AVL树本质上还是一棵二叉搜索树，它的特点是： 本身首先是一棵二叉搜索树。 每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）
数据结构——平衡二叉树(AVL树)之插入
weixin_57023347的博客
06-17 7306
文章目录前言一.定义二.基本操作1.查找，删除2.插入(如何调整)如何调整代码实现插入 前言 首先我们来思考一下一个普通二叉树保存数据，如果想查找一个数据，由于普通二叉树保存数据是随机的，要找到数据的时间复杂度为O(n)。后面为了方便 ，我们又学习二叉搜索树，它的定义是将比根节点小的数放左边，比根节点大的数放右边，并且每一课子树都是二叉搜索树这样使得数据在树上存储有一定 的规律，在一定情况下查找起来很方便。但是，二叉搜索数当给出数据的顺序不同时，二叉搜索树也会不同。比如如果给出的序列为{1，2，3，4，5}
C/C++数据结构（十一）—— 平衡二叉树（AVL树）
热门推荐
Edison's 小宇宙
01-19 2万+
平衡二叉树又称为 AVL 树，其实就是一颗 平衡的二叉搜索树，解决了二叉搜索树的不平衡问题。
广工数据结构实验——平衡二叉树
07-06
本实验“广工数据结构实验——平衡二叉树”着重探讨了一种特殊类型的数据结构，即平衡二叉树。平衡二叉树是二叉搜索树（Binary Search Tree, BST）的一个变体，它通过保持树的高度平衡来确保查找、插入和删除操作的...
广工数据结构课程设计大作业-平衡二叉树-Java实现（数据结构期末）
11-13
在本项目中，我们主要探讨的是数据结构领域中的一个重要概念——平衡二叉树，并通过Java编程语言进行实现。平衡二叉树是一种特殊的二叉搜索树，它的左右子树的高度差不超过1，从而保证了树的平衡性，进一步提高了...
数据结构平衡二叉排序树
02-13
在本实验中，我们主要探讨的是数据结构中的一个关键概念——平衡二叉排序树（Balanced Binary Sort Tree），也称为AVL树。AVL树是一种自平衡的二叉搜索树，它的每个节点都包含一个平衡因子，这个因子是该节点的左...
数据结构——二叉树(c).doc
09-25
二叉树的插入和删除操作通常涉及到递归和平衡问题，如AVL树和红黑树等自平衡二叉搜索树，它们在保持二叉搜索树性质的同时，通过旋转操作维持树的高度平衡，从而确保操作效率。 总结来说，二叉树是一种强大的数据...
数据结构实验——树和二叉树子系统
07-31
在本实验“数据结构实验——树和二叉树子系统”中，我们将深入理解二叉树的特性和操作。 首先，实验目的主要涵盖以下几个方面： 1. **理解二叉树特点**：二叉树的每个节点至多有两个子节点，它允许快速查找、插入...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 274
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 405
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
java算法原理
jylee的博客
07-25 834
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
数据结构的概念和术语
2303_78660417的博客
07-24 524
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科。数据结构的基本数据结构包括两部分，线性结构跟非线性结构。
c语言（7.23）
fhgfyrsg的博客
07-23 738
【代码】c语言（7.23）
数据结构初阶(C语言)-二叉树-顺序表建堆
xiuwoaiailixiya的博客
07-23 1130
int size;}HP;由于堆在本质上是基于顺序表结构去实现的，所以接下来我们所介绍的实现内容重点介绍与顺序表的不同的地方，相同部分则直接给出代码。
【初阶数据结构篇】时间（空间）复杂度
2301_79849925的博客
07-23 1016
​ 在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运⾏时间。时间复杂度是衡量程序的时间效率，那么为什么不去计算程序的运⾏时间呢？​ 1.因为程序运⾏时间和编译环境和运⾏机器的配置都有关系，⽐如同⼀个算法程序，⽤⼀个⽼编译器进⾏编译和新编译器编译，在同样机器下运⾏时间不同。​ 2.同⼀个算法程序，⽤⼀个⽼低配置机器和新⾼配置机器，运⾏时间也不同。​ 3.并且时间只能程序写好后测试，不能写程序前通过理论思想计算评估。
【JavaScript】`Map` 数据结构
lph159的博客
07-25 343
允许您使用各种类型的值作为键，不限于字符串或符号。按照插入顺序保留键值对，而对象的键的遍历顺序可能会根据不同的 JavaScript 引擎有所不同。的基本概念、用法、常见操作以及与对象的对比，帮助您全面掌握这一数据结构。与传统的对象（Object）不同，和对象在某些方面类似，但它们在使用场景和性能上有一些显著区别。保留了键值对的插入顺序，且键是唯一的，这意味着在同一个。对象适用于结构化的静态数据，而。是一种键值对集合，其中键和值都可以是任意类型。对象的键只能是字符串或符号，而。更适合需要动态操作的场景。
数据结构（3）（顺序栈）
qq_54094530的博客
07-25 555
栈是限定仅在栈顶进行插入和删除操作的线性表，在操作的时候，只允许栈顶改变不允许栈底改变，具有后进先出的特征。
计算机科学学院详解：数据结构——树与二叉树基础
本章节主要探讨了计算机科学与技术学院的数据结构课程中的重要内容——树与二叉树。在第六章中，学习者将深入理解以下几个关键概念： 1. 树的定义和基本术语： - 树被定义为一个有限集合，其中包含一个特殊的节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值