数据结构和算法-10.树结构基础部分

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

1. 二叉树

1.1 为什么需要二叉树

  1. 数组存储方式

优点：通过下标方式访问元素，速度快。对于有序数组，可以使用二分查找提高检索速度
缺点：如果要检索具体某个值，或插入值会整体移动，效率低

数组存储

  1. 链式存储方式

优点：插入，删除节点，只需要链接到链表即可，效率很好
缺点，进行检索时，需要从头节点开始遍历，效率较低

链表

  1. 树存储方式

能提高数据存储，读取的效率，比如利用二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，也可以保证数据的插入删除速度

树

1.2 树的概念

常用术语
二叉树

子节点分为左节点和右节点
二叉树

满二叉树

所有叶子节点都在最后一层，节点总数为2^n-1，n为层树，称为满二叉树
满二叉树
完全二叉树

该二叉树的所有叶子节点都在最后一层或倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，称为完全二叉树
完全二叉树

1.3 二叉树的遍历

  • 前序遍历：先输出父节点，再遍历左子树和右子树
  • 中序遍历：先遍历左子树，再输出父节点，再遍历右子树
  • 后序遍历：先遍历左子树，再遍历右子树，最后输入父节点
    二叉树的遍历

1.4 二叉树的查找

查找

1.5 二叉树的删除

删除

public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        //创建节点
        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
        HeroNode node5 = new HeroNode(5, "关胜");

        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        binaryTree.setRoot(root);

//        System.out.println("前序遍历");
//        binaryTree.preOrder();
//        System.out.println("中序遍历");
//        binaryTree.infixOrder();
//        System.out.println("后序遍历");
//        binaryTree.postOrder();
//        System.out.println("前序查找");
//        HeroNode resNode = binaryTree.preOrderSearch(5);
//        if (resNode != null) {
//            System.out.println(resNode);
//        } else {
//            System.out.println("没有找到");
//        }
//        System.out.println("后序查找");
//        resNode = binaryTree.postOrderSearch(5);
//        System.out.println("中序查找");
//        resNode = binaryTree.infixOrderSearch(5);

        //删除
        System.out.println("删除前");
        binaryTree.preOrder();
        binaryTree.delNode(5);
        System.out.println("删除后");
        binaryTree.preOrder();
    }
}

//定义二叉树
class BinaryTree {
    private HeroNode root;

    public void setRoot(HeroNode root) {
        this.root = root;
    }

    //前序遍历
    public void preOrder() {
        if (this.root != null) {
            this.root.preOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    //中序
    public void infixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    //后序
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    //前序查找
    public HeroNode preOrderSearch(int no) {
        if (root != null) {
            return root.preOrderSearch(no);
        } else {
            return null;
        }
    }

    //中序查找
    public HeroNode infixOrderSearch(int no) {
        if (root != null) {
            return root.infixOrderSearch(no);
        } else {
            return null;
        }
    }

    //前序查找
    public HeroNode postOrderSearch(int no) {
        if (root != null) {
            return root.postOrderSearch(no);
        } else {
            return null;
        }
    }


    //删除节点
    public void delNode(int no) {
        if (root != null) {
            //如果只有一个root节点，判断root是不是要判断的节点
            if (root.getNo() == no) {
                root = null;
            } else {
                root.delNode(no);
            }
        } else {
            System.out.println("这是空树");
        }
    }
}


//HeroNode节点
class HeroNode {
    private int no;
    private String name;
    private HeroNode left;//默认null
    private HeroNode right;//默认null

    //前序遍历
    public void preOrder() {
        System.out.println(this);//先输出父节点
        //递归左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        //递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    //中序遍历
    public void infixOrder() {
        //递归向左子树遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        //输出父节点
        System.out.println(this);
        //递归右子树中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    //后续遍历
    public void postOrder() {
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.println(this);
    }


    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    //前序遍历查找
    public HeroNode preOrderSearch(int no) {
        System.out.println("前序开始查找");
        //比较当前节点
        if (this.no == no) {
            return this;
        }
        HeroNode resNode = null;
        //左子节点
        if (this.left != null) {
            resNode = this.left.preOrderSearch(no);
        }
        if (resNode != null) {//说明左子树上找到了
            return resNode;
        }
        //右子节点
        if (this.right != null) {
            resNode = this.right.preOrderSearch(no);
        }
        return resNode;
    }

    //中序遍历查找
    public HeroNode infixOrderSearch(int no) {

        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("中序开始查找");
        if (this.no == no) {
            return this;
        }
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    //后序遍历查找
    public HeroNode postOrderSearch(int no) {

        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.postOrderSearch(no);
        }
        if (resNode != null) {//左子树已经找到
            return resNode;
        }
        if (this.right != null) {
            resNode = this.right.postOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("后序开始查找");
        //左右子树都没有找到
        if (this.no == no) {
            return this;
        }
        return resNode;
    }

    //递归删除节点
    //如果删除的是叶子节点，则删除该节点。删除的是非叶子节点，则删除该子树
    public void delNode(int no) {
        if (this.left != null && this.left.no == no) {
            this.left = null;
            return;
        }
        if (this.right != null && this.right.no == no) {
            this.right = null;
            return;
        }
        if (this.left != null) {
            this.left.delNode(no);
        }
        if (this.right != null) {
            this.right.delNode(no);
        }
    }
}

2. 顺序存储二叉树

2.1 顺序存储二叉树的概念

  • 从数据存储来看，数组存储方式和树的存储方式可以相互转换
  • 顺序二叉树通常只考虑完全二叉树
  • 第n个元素的左子节点为2n+1
  • 第n个元素的右子节点为2n+2
  • 第n个元素的父节点为(n-1)/2

转换

2.2 顺序存储二叉树的遍历

  • 八大排序算法中的堆排序，会使用到顺序存储二叉树
public class ArrayBinaryTreeDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(arr);
        arrayBinaryTree.preOrder();
    }
}

//ArrayBinaryTree类实现顺序存储二叉树遍历
class ArrayBinaryTree {
    private int[] arr;//存储数据节点的数组

    public ArrayBinaryTree(int[] arr) {
        this.arr = arr;
    }

    public void preOrder() {
        this.preOrder(0);
    }

    //顺序存储二叉树的前序遍历,index数组的下标
    public void preOrder(int index) {
        if (arr == null || arr.length == 0) {
            System.out.println("数据为空");
        }
        System.out.println(arr[index]);
        //向左递归遍历
        if ((2 * index + 1) < arr.length) {
            preOrder(2 * index + 1);
        }
        //向右递归
        if ((2 * index + 2) < arr.length) {
            preOrder(2 * index + 2);
        }
    }
}

3. 线索化二叉树

3.1 基本介绍

  • n个节点的二叉链表中含有n+1个空指针域，利用二叉链表中的空指针域，存放指向该节点在某次遍历次序下的前驱和后继节点的指针，这种附加的指针称为“线索”
  • 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，可以分为前序线索二叉树、中序线索二叉树和后续线索二叉树
  • 一个节点的前一个节点，称为前驱节点
  • 一个节点的后一个节点，称为后继节点

线索化二叉树

3.2 线索化二叉树的生成

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

3.3 线索化二叉树的遍历

public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {
        Node root = new Node(1, "tom");
        Node node2 = new Node(3, "jack");
        Node node3 = new Node(6, "smith");
        Node node4 = new Node(8, "mary");
        Node node5 = new Node(10, "king");
        Node node6 = new Node(14, "dim");

        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

        ThreadedBinaryTree binaryTree = new ThreadedBinaryTree();
        binaryTree.setRoot(root);
        binaryTree.threadedNodes(root);
        Node leftNode = node5.getLeft();
        System.out.println("10号节点的前驱节点" + leftNode);
        System.out.println("10号节点的后继节点" + node5.getRight());

        System.out.println("线索化的方式遍历线索化二叉树");
        binaryTree.threadedList();
    }
}


//定义线索化二叉树
class ThreadedBinaryTree {
    private Node root;

    //指向前驱节点的指针
    private Node pre = null;

    public void setRoot(Node root) {
        this.root = root;
    }

    //遍历线索化二叉树的方法
    public void threadedList() {
        //存储当前遍历的节点，从root开始
        Node node = root;
        while (node != null) {
            //循环找到leftType=1的节点
            while (node.getLeftType() == 0) {
                node = node.getLeft();
            }
            System.out.println(node);
            //当前节点的右指针指向的是后继节点，一直输出
            while (node.getRightType() == 1) {
                //当前节点的后继节点
                node = node.getRight();
                System.out.println(node);
            }
            //替换遍历的节点
            node = node.getRight();

        }
    }

    //对二叉树进行中序线索化
    public void threadedNodes(Node node) {
        if (node == null) {
            return;
        }
        //1.线索化左子树
        threadedNodes(node.getLeft());
        //2.线索化当前节点
        //处理当前节点的前驱节点
        if (node.getLeft() == null) {
            //当前节点的左指针指向前驱节点
            node.setLeft(pre);
            //修改当前节点的左指针类型，指向前驱节点
            node.setLeftType(1);
        }
        //处理后继节点
        if (pre != null && pre.getRight() == null) {
            //前驱节点的右指针指向当前节点
            pre.setRight(node);
            pre.setRightType(1);
        }
        //每处理一个节点后，让当前节点是下一个节点的前驱节点
        pre = node;
        //3.线索化右子树
        threadedNodes(node.getRight());
    }

    //前序遍历
    public void preOrder() {
        if (this.root != null) {
            this.root.preOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    //中序
    public void infixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    //后序
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    //前序查找
    public Node preOrderSearch(int no) {
        if (root != null) {
            return root.preOrderSearch(no);
        } else {
            return null;
        }
    }

    //中序查找
    public Node infixOrderSearch(int no) {
        if (root != null) {
            return root.infixOrderSearch(no);
        } else {
            return null;
        }
    }

    //前序查找
    public Node postOrderSearch(int no) {
        if (root != null) {
            return root.postOrderSearch(no);
        } else {
            return null;
        }
    }


    //删除节点
    public void delNode(int no) {
        if (root != null) {
            //如果只有一个root节点，判断root是不是要判断的节点
            if (root.getNo() == no) {
                root = null;
            } else {
                root.delNode(no);
            }
        } else {
            System.out.println("这是空树");
        }
    }
}

//Node节点
class Node {
    private int no;
    private String name;
    private Node left;//默认null
    private Node right;//默认null

    //lefType=0表示指向的是左子树，=1表示指向前驱节点
    //rightType=0表示指向的是右子树，=1表示指向后继节点
    private int leftType;
    private int rightType;

    public int getLeftType() {
        return leftType;
    }

    public void setLeftType(int leftType) {
        this.leftType = leftType;
    }

    public int getRightType() {
        return rightType;
    }

    public void setRightType(int rightType) {
        this.rightType = rightType;
    }

    //前序遍历
    public void preOrder() {
        System.out.println(this);//先输出父节点
        //递归左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        //递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    //中序遍历
    public void infixOrder() {
        //递归向左子树遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        //输出父节点
        System.out.println(this);
        //递归右子树中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    //后续遍历
    public void postOrder() {
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.println(this);
    }


    public Node(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Node getLeft() {
        return left;
    }

    public void setLeft(Node left) {
        this.left = left;
    }

    public Node getRight() {
        return right;
    }

    public void setRight(Node right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    //前序遍历查找
    public Node preOrderSearch(int no) {
        System.out.println("前序开始查找");
        //比较当前节点
        if (this.no == no) {
            return this;
        }
        Node resNode = null;
        //左子节点
        if (this.left != null) {
            resNode = this.left.preOrderSearch(no);
        }
        if (resNode != null) {//说明左子树上找到了
            return resNode;
        }
        //右子节点
        if (this.right != null) {
            resNode = this.right.preOrderSearch(no);
        }
        return resNode;
    }

    //中序遍历查找
    public Node infixOrderSearch(int no) {

        Node resNode = null;
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("中序开始查找");
        if (this.no == no) {
            return this;
        }
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    //后序遍历查找
    public Node postOrderSearch(int no) {

        Node resNode = null;
        if (this.left != null) {
            resNode = this.left.postOrderSearch(no);
        }
        if (resNode != null) {//左子树已经找到
            return resNode;
        }
        if (this.right != null) {
            resNode = this.right.postOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("后序开始查找");
        //左右子树都没有找到
        if (this.no == no) {
            return this;
        }
        return resNode;
    }

    //递归删除节点
    //如果删除的是叶子节点，则删除该节点。删除的是非叶子节点，则删除该子树
    public void delNode(int no) {
        if (this.left != null && this.left.no == no) {
            this.left = null;
            return;
        }
        if (this.right != null && this.right.no == no) {
            this.right = null;
            return;
        }
        if (this.left != null) {
            this.left.delNode(no);
        }
        if (this.right != null) {
            this.right.delNode(no);
        }
    }
}
盖大大
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
极客时间-数据结构与算法-王争.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： ...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
mysql详解之B+树的查询时间复杂度
yunduanyou的博客
12-08 5502
在内存里（不考虑磁盘io的特殊性），n叉树的查询时间复杂度都是O(logN)。
关于B+树的时间复杂度分析
wufeifan_learner的博客
11-16 2万+
找了好长时间关于B+树的时间复杂度的博客，没找到几篇相关的，有相关的博客基本都是错误的，当然不排除我没找到的情况。 B+树的建立我就简单的说一下，避免大家搞混B树和B+树，这也是面试官喜欢考察的地方（好多面试官对这里也是比较糊涂的，因为面试官不一定是做数据库或者索引相关研究的）。 B树和B+树最大的区别就是，B树是将各种信息保存在所有节点中的，B+树是将各种信息保存在叶子中的。这样一来，对于每一个要查找的值来说，B+树都需要从根节点到叶子节点找一遍，那么时间复杂度与树高成正比；B树只需要找到相应节点就停止
B+树检索的时间复杂度
m0_37313888的博客
04-22 2万+
https://zhuanlan.zhihu.com/p/110202102 前几天面了头条深圳的暑期实习，在一面中和面试官讨论到了这样一个问题： 面试官抛出了一个很经典的考题：许多数据库为什么使用B+树作为索引结构，有什么好处？ 我想当然地觉得B+树就是个平衡二叉查找树的升级版，既然后者的时间查询复杂度为，那B+树作为m叉树，自然就是咯？ 面试官：不对不对，你想想，虽然你可以认为一...
b+树的时间复杂度
最新发布
qq_21277357的博客
02-25 321
b+树会先从根节点开始往下找到叶子节点，查找过程类似二分查找，每次查询都能缩小查询范围的一半,所以时间复杂度是O(logn)
angular6 TS 树实现前端搜索、选中、取消选中功能
抄经书的程序猿
10-03 636
angular8 实现树组件相关思路 充分利用Map，key 为路径，值为节点引用。 存储树所有节点的Map : allLeafNodesMap: Map<string, NodeTreeItem> = new Map([]); 1，树节点 接口 export interface NodeTreeItem { type: string | FieldsEnum; // 节点类型，用于显示节点icon ，FieldsEnum 为枚举 name: string; // 节.
数据结构和算法-Java版.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： ...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
数据结构-算法.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： ...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
基础算法与数据结构 -- Java 实现.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： ...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
DataStructure-尚硅谷-数据结构与算法-数据结构.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
b+树的时间复杂度_植树节，那些年程序猿种的那些树
weixin_39532754的博客
01-19 1689
公历 3 月 12 日是一年一度的植树节。旨在宣传保护森林，并动员群众参加植树造林活动。说到树，程序猿们肯定不陌生，趁着这个植树节到来之时普及一下程序猿们经常遇见的树。转自：五分钟学算法作者：程序猿小吴和小伙伴 进击的Hello_World1. 二叉搜索树 定义二叉搜索树又称二叉查找树，亦称为二叉排序树。设 x 为二叉查找树中的一个节点，x 节点包含关键字 key，节点x 的 key 值记为 ke...
B+ Tree
HelloWorld
01-24 848
B+ Tree什么是B+Insert简单的insert复杂的InsertDelete简单的delete复杂的delete时间复杂度 什么是B+ B+ tree是平衡二叉树 每个节点包含k个元素, k的范围在 d <= k <= 2d 之间（也就是Minimun 50% occupancy, except for root) d 被叫做 the order of the tree 比如d = 2，则 2 <= k <= 4, k最小是2, 保证 Minimun 50% occ
b+树时间复杂度_深入理解数据库系统之存储存引擎（二叉搜索树）
weixin_39737757的博客
11-24 525
B树是数据库存储引擎使用的最多的存储结构之一。许多开源数据库系统也都大量使B用树作为存储结构，多年来已经证明它们能够胜任大多数使用场景。早在1971年鲁道夫·拜尔(Rudolph Bayer)和爱德华·M·麦克立特(Edward M. McCreight)就提出了B树这种数据结构，并受到广泛的应用。到1979年，B树已经发展出了许多变种形式。在深入讨论B树之前，让我们首先讨论一下传统搜索树，例如，...
b+树时间复杂度_前端大神用的学习笔记：线段树和树状数组
weixin_39808893的博客
11-20 479
全文篇幅较长，细心理解一定会有收获的♪(^∇^*)。1|0线段树1|1一些概念    线段树是一种二叉搜索树，每一个结点都是一个区间(也可以叫作线段，可以有单点的叶子结点)，有一张比较形象的图如下(侵删)：    可以看出，线段树除根结点外的其他节点，都由其父节点二分长度得到，这种优秀的性质使得我们可以把它近似看成是一棵完全二叉树。而完全二叉树可以用一个数组表示：设根节点下标为 nownow (在...
B+树的时间复杂度
weixin_52857012的博客
09-09 210
说的最多的就是log2(m)*logm(n),得证方式是当遍历B+树时采用二分法遍历 遍历时间复杂度为log2（m）而后续有人用图解工具演示了一下发现该公式曲线和log2(n)是重合的，经公式推导后也发现二者可相等。从上至下遍历节点个数是b+树的深度logm(n) 二者相乘即为b+树时间复杂度。所以最后是哪个我个人理解是都可以，目前觉得靠谱的只有这个说法了哈~看了很多博客 以下全凭个人理解，仅供参考。
142面试必问：分析一下为什么B+树更适合作为索引的结构以及索引原理
AI乔治
11-26 387
更多面试题：面试题内容聚合 mysql的B+树索引 查找使用了二分查找，redis 跳表也使用了二分查找法，kafka查询消息日志也使用了二分查找法，二分查找法时间复杂度O(logn); 在MySQL中，主要有四种类型的索引，分别为：B-Tree索引，Hash索引，Fulltext索引(MyISAM 表)和R-Tree索引，本文讲的是B-Tree索引。 后面的索引原理一定要看，太重要了，阿里两个人都问这个mysql的索引原理 mysql使用了 B+索引： B树：有序数组+平衡多叉树；...
b 树查找时间复杂度_你心里是没点B树吗？
weixin_39702559的博客
12-09 1310
点击上方“零一视界”，选择“星标”公众号资源干货，第一时间送达1 引言数据库的增删改查等操作是开发过程中最为常见也是尤为重要的，尤其是现在大数据的兴起，导致数据存储量急剧增加，提升数据的操作效率就变得尤为关键。大部分数据库的索引都采用树的结构存储，这是因为树的查询效率相对较高，且保持有序。对于二叉搜索树的时间复杂度是O(logN)，在算法以及逻辑上来分析，二叉搜索树的查找速度以及数据比较...
阿里面试，问了B+树，这个回答让我通过了
热门推荐
05-06 4万+
上周我通过阿里一面，岗位是客户端开发工程师。面试过程中面试官问了B+树，回答时面试官一直点头（应该回答得还不错，过了），今天详细讲一讲B+树。
mysql B 树时间复杂度_数据结构 4 时间复杂度、B-树 B+树 具体应用与理解
weixin_34270705的博客
01-19 373
前言面试中，经常会问到有关于MYSQL 索引的相关概念，我们之前也都学过有关树的概念、以及二叉树、二叉查找树、红黑树等。这一节，来关注经常是数据库索引中使用的B-树在说这些之前，我们需要了解时间复杂度以及空间复杂度。时间复杂度时间复杂度，用于鉴定一个算法的好坏、很多时候，比如跑一个for 循环一个数组排序，有冒泡、二分法等方法。相比于冒泡。二分法很占优势，为什么呢?因为比较的次数少、并且做的无用功...
数据结构与算法 - 图
09-03
在学习整个数据结构的过程中，我们可以使用编程语言如Java来实现常用的数据结构，包括数组、链表、栈、队列、树、字典和图。通过这个过程，我们能够更深入地理解Java集合类库和基本算法，比如树的遍历算法和图的遍历...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值