Java数据结构与算法（哈希表，二叉树，顺序存储二叉树，线索化二叉树）

最新推荐文章于 2023-04-10 15:28:30 发布
最新推荐文章于 2023-04-10 15:28:30 发布
阅读量802 收藏 1
点赞数
文章标签： 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48627750/article/details/121323352
版权

哈希表

哈希表的基本介绍
散列表（Hash table，也叫哈希表），是根据关键码值（key value）而直接进行访问的数据结构，也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度，这个映射函数叫做散列函数，存放记录的数组叫做散数列

哈希表主要用在一些应用程序和数据库之间以提高数据查询速率的手段，为了提高程序与数据库之间的交互速率，一般在他俩中间会有一个缓存层，缓存层缓存了一些用户经常用到的数据，这样在用户每次查找的时候就不用程序在到数据库中进行海量的查找了，缓存层一般会用Redishe Memcache,也可以使用自己写的哈希表，数组 + 链表，数组 + 二叉树。
在这里插入图片描述

其实哈希表存储数据就是把数据模它的哈希表大小，在把得到的模作为此数据存储的链表编号，这样同过取模就可以快速定位到数据应该处在哪条链表上，理解了这一点其他的也就很容易理解了，哈希表的各种操作归根结底还是对链表的操作，只是它哈希表是要操作很多条链表而已

代码实现：

//创建hashTable来管理哈希表
class hashTable {
    private int size;//表示hash表中有多少条链表
    //创建一个hash表，即链表数组
    private nodeLink[] linkList;
    //带参构造方法
    public hashTable(int size) {
        //初始化链表
        this.size = size;
        linkList = new nodeLink[size];
        //初始化每个hash表
        for(int i = 0;i < size;i++) {
            linkList[i] = new nodeLink();
        }
    }
    //向hash表中添加元素
    public void add(node Node) {
        //找到元素应该插入的链表下标
        int insertSite = hashFun(Node.id);
        //将元素插入到相应的位置
        linkList[insertSite].add(Node);
    }
    //遍历hash表的元素
    public void list() {
        //循环遍历hash表中的每一个链表
        for(int i = 0;i < size;i++) {
            linkList[i].list(i);
        }
    }
    //查找元素
    public void findNode(int id) {
        //首先确定查找的元素应该在那一条链表里
        int number = hashFun(id);
        //在相应的链表里进行查找
        node node = linkList[number].findNode(id);
        if(node == null) {
            System.out.println("没有找到相应的元素");
        }
        else{
            System.out.println(node.value);
        }
    }
    //删除元素
    public void delete(int id) {
        //确定删除元素应该处在的链表标号
        int number = hashFun(id);
        linkList[number].delete(id);
    }

    //用简单的取模方法编写简单的散列函数,用于找到插入的元素应该放在hash表的什么位置（放在哪条链表里）
    public int hashFun(int id) {
        return id % size;
    }
}
//表示链表的每个结点
class node {
    int id;
    int value;
    node next;
    public  node(int id,int value) {
        this.id = id;
        this.value = value;
    }
}
//表示每条链表
class nodeLink {
    private node head;
    //向链表中添加元素
    public void add(node Node) {
        if(head == null) {
            head = Node;
            return ;
        }
        //创建一个指针用于查找插入的位置
        node temp = head;
        //对链表进行循环，找插入位置
        while(true) {
            //插入的位置是链表的末尾位置
            if(temp.next == null)
                break;
            temp = temp.next;
        }
        //将目标值插入到指定位置
        temp.next = Node;
    }
    //遍历链表的信息
    public void list(int no) {
        if(head == null) {
            System.out.println("第"+ no +"链表为空");
            return ;
        }
        node temp = head;
        while(true) {
            if(temp == null)
                break;
            System.out.println(temp.value);
            temp = temp.next;
        }
    }
    //查找元素
    public node findNode(int id) {
        //判断此链表是否为空
        if(head == null) {
            System.out.println("链表为空");
            return null;
        }
        node temp = head;
        while(true) {
            if(temp.id == id) {
                break;
            }
            if(temp.next == null) {
                temp = null;
                break;
            }
            temp = temp.next;
        }
        return temp;
    }
    //删除元素
    public void delete(int id) {
        if(head == null) {
            System.out.println("找不到删除的数据");
            return ;
        }
        if(head.id == id) {
            head = null;
            return ;
        }
        //定义指针，用于查找并删除结点
        node temp = head;
        node tempNext = head.next;
        while(true) {
            if(tempNext == null) {
                System.out.println("找不到删除的数据");
                return ;
            }
            if(tempNext.id == id)
                break ;
        }
        //进行删除操作
        temp.next = tempNext.next;
        System.out.println("删除成功");
        return ;
    }
}

二叉树

为什么会需要树这种数据结构
数组，链表，树三种数据结构的比较
（1）数组存储方式的分析
优点：通过下标方式访问元素，速度快，对于有序数组，还可以使用微分查找提高检索速度。
缺点：如果要检索某个具体的值，或者插入值（按照一定顺序）会整体移动，效率较低
（2）链式存储方式的分析
优点：在一定程度上对数组存储方式有优化（比如：插入一个数值结点，只需要将插入结点，链接到链表中即可，删除效率也很好）
缺点：在进行检索时，效率仍然较低，比如（检索某个值，需要从头结点开始遍历）
（3）树存储方式的分析
能提高数据存储，读取的效率，比如用二叉排序树，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度

树所需要知道的一些基本概念：
在这里插入图片描述

（1）结点：A,B,D,E…这些被称之为结点
（2）根结点：像A这种没有任何结点指向它的叫做根结点
（3）父结点：A是B和C的父节点，B又是D和E的父节点，像这种它直接指向谁，他就是谁的父节点
（4）子节点：B是A的子节点，C是A的子节点，像这种是直接谁指向的它，它就是谁的子节点
（5）叶子结点：像H，E,F，G这种没有子节点的结点
（6）结点的权：就是结点的值
（7）路径（从root结点找到某结点的路线）
（8）层：右边黄色部分标注的
（9）子树：一整棵树的一部分，但并不是一个树的全部
（10）树的高度：最大层数
（11）森林：多棵子树构成森林

二叉树：每个结点最多只能有两个子节点的树
二叉树的结点分为左节点和右节点
如果该二叉树的所有叶子结点都在最后一层，并且结点总数=2^n-1,n为层数，则我们称之为满二叉树
如果二叉树的所有叶子结点都在最后一层或者倒数第二层，而且最后一层的叶子结点在左边连续，倒数第二层的叶子结点在右边连续，我们称之为 王权二叉树

在这里插入图片描述
二叉树的前，中，后序遍历

步骤
1.创建一棵二叉树
2.前序遍历
2.1先输出当前结点（初始的时候是root结点）
2.2如果左子节点不为空，则递归继续前序遍历
2.3如果右子节点不为空，则递归继续前序遍历
3.中序遍历
3.1如果当前结点的左子节点不为空，则递归中序遍历
3.2输出当前结点
3.3如果当前结点的右子节点不为空，则递归中序遍历
4.后序遍历
4.1如果当前结点的左子节点不为空，则递归后序遍历
4.2如果当前结点的右子节点不为空，则递归后序遍历
4.3输出当前结点

class BinaryTree {
    private Node root;

    public void setRoot(Node 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("这个二叉树是空的");
    }
}

class Node {
    private int ID;
    private char Code;
    //左结点
    private Node left;
    //右节点
    private Node right;
    public Node(int id , char code) {
        ID = id;
        Code = code;
    }

    public int getID() {
        return ID;
    }

    public void setID(int ID) {
        this.ID = ID;
    }

    public char getCode() {
        return Code;
    }

    public void setCode(char code) {
        Code = code;
    }

    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{" +
                "ID=" + ID +
                ", Code=" + Code +
                '}';
    }

    //前序遍历
    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 static void main(String[] args) {
        Node root = new Node(1,'A');
        Node node1 = new Node(2,'B');
        Node node2 = new Node(3,'C');
        Node node3 = new Node(4,'D');
        BinaryTree N = new BinaryTree();
        root.setLeft(node1);
        root.setRight(node2);
        node2.setRight(node3);
        N.setRoot(root);
    }

前序输出顺序
在这里插入图片描述
中序输出顺序
在这里插入图片描述
后序输出顺序
在这里插入图片描述
二叉树的查找
上面知道了怎么对二叉树进行遍历，那么查找相信也很简单，就只需要在每一次递归中输出结点的语句改成判断语句，判断此结点是否为目标值即可。

二叉树删除结点
（1）如果删除的结点是叶子结点，则删除该结点
（2）如果删除的结点是非叶子结点，则删除该子树
代码实现：

 //删除结点
 class BinaryTree {
    public void delete(int id) {
        if(root != null) {
            if(root.getID() == id) {
                root = null;
            } else {
              root.delete(id);
            }
        } else {
            System.out.println("此二叉树为空，无法进行删除操作");
        }
    }
}
class Node {
	 //结点的删除
    public void delete(int id) {
        //先判断其右子节点是否为空，在判断其是否为删除的目标结点
        if(this.left != null &&this.left.ID == id) {
            this.left = null;
            return ;
        }
        //在对右子节点进行相同的操作
        if(this.right != null && this.right.ID == id) {
            this.right = null;
            return ;
        }
        //如果没有找到相应的目标结点，就进行递归查找
        //左子节点递归
        if(this.left != null) {
            this.left.delete(id);
        }
        //右子节点递归
        if(this.right != null) {
            this.right.delete(id);
        }
        return ;
    }
}

顺序存储二叉树

概念：
从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树叶可以转换成数组，
在这里插入图片描述
如上图的二叉树结点，要求以数组的方式来存放arr：[1,2,3,4,5,6,7]
要求在遍历数组arr时，仍然可以以前序遍历，中序遍历和后序遍历的方式完成结点的遍历

顺序存储二叉树的特点：
（1）顺序二叉树通常只考虑完全二叉树
（2）第n个元素的左子节点为2n+1
（3）第n个元素的右子节点为2n+2
（4）第n个元素的父结点为（n-1）/2
（5）n:表示二叉树中的第几个元素（按0开始编号，如图所示）

代码实现：

class ArrBinaryTree {
    private int[] arr;

    public ArrBinaryTree(int[] arr) {
        this.arr = arr;
    }
    //前序遍历顺序存储二叉树
    public void preOrder(int index) {
        if(arr == null || arr.length == 0) {
            System.out.println("顺序二叉树是空的");
        }
        //直接输出此结点
        System.out.println(arr[index]);
        //递归此结点的左子节点
        if(index*2+1 < arr.length) {
            preOrder(index*2+1);
        }
        //递归此结点的右子节点
        if(index*2+2 < arr.length) {
            preOrder(index*2+2);
        }
    }
    //中序遍历顺序存储二叉树
    public void infixOrder(int index) {
        if(arr == null || arr.length == 0) {
            System.out.println("顺序二叉树是空的");
        }
        //递归此结点的左子节点
        if(index*2+1 < arr.length) {
            preOrder(index*2+1);
        }
        //直接输出此结点
        System.out.println(arr[index]);
        //递归此结点的右子节点
        if(index*2+2 < arr.length) {
            preOrder(index*2+2);
        }
    }
    //后序遍历顺序存储二叉树
    public void postOrder(int index) {
        if(arr == null || arr.length == 0) {
            System.out.println("顺序二叉树是空的");
        }
        //递归此结点的左子节点
        if(index*2+1 < arr.length) {
            preOrder(index*2+1);
        }
        //递归此结点的右子节点
        if(index*2+2 < arr.length) {
            preOrder(index*2+2);
        }
        //直接输出此结点
        System.out.println(arr[index]);
    }
}

线索化二叉树

线索化二叉树有何作用：
就是充分利用每个结点的左右指针，不造成资源的浪费

（1）n个结点的二叉树中含有n+1【公式2n-(n-1) = n+1】个空指针域。利用二叉链表中的空指针域，存放指向结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为“线索”）
（2）这种加上了线索的二叉树链表称之为线索链表，相应的二叉树成为线索二叉树（Threaded Binary Tree）.根据线索性质的不同，线索二叉树可分为前序线索二叉树，中序线索二叉树和后序线索二叉树三种
（3）一个结点的前一个结点，称之为前驱结点
（4）一个结点的后一个结点，称之为后继结点
例如一个二叉树前序遍历的顺序为【1，2，4，5，3，6，7】，那么1就没有去前驱结点，2就是1的后继结点，而对于2来说1就是他的前驱结点，4就是他的后继结点

在这里插入图片描述
说明：当线索化二叉树后，Node结点的属性left和right有如下情况
（1）left指向的是左子树，也可能是指向的前驱结点，比如1结点left指向的左子树，而10结点的left指向的就是前驱结点
（2）right指向的是右子树，也可能是指向后继结点，比如1结点right指向的是右子树，而10结点的right指向的是后继结点
代码实现：

此代码为中序线索化二叉树的模板，如果想实现前序，后序线索化二叉树只有需要将ThreadNode方法中的，左递归遍历线索化，线索化当前结点，右递归遍历线索化，三者的顺序调换一下即可


class ThreadBinaryTree {
    private threadNode root;
    //记录前驱结点
    private threadNode pre = null;

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

    public void ThreadNode() {
        this.ThreadNode(root);
    }

    //为二叉树线索化，node为线索化的结点
    public void ThreadNode (threadNode node) {
        if(node == null) {
            return ;
        }
        //左递归遍历线索化
        ThreadNode(node.getLeft());
        //线索化当前结点
            //先线索化左指针
        if(node.getLeft() == null) {
            node.setLeft(pre);
            //改变leftType
            node.setLeftType(0);
        }
            //线索化右指针是应该在下一次循环里面来进行，因为我们在线索化某一个点的时候都要先确定它的前驱结点，
            //理所当然，我们确定他的后驱结点就要到他的后驱结点进行更改
        if(pre != null && pre.getRight() == null) {
            pre.setRight(node);
            //改变rightType
            pre.setRightType(0);
        }
        //将现在的结点设置为前驱结点
        pre = node;
        //右递归遍历线索化
        ThreadNode(node.getRight());
    }
    //遍历线索化二叉树
    public void threadList() {
        threadNode temp = root;
        while(temp != null) {
             //先根据leftType找到开始的那个点
            while (temp.getLeftType() == 1 ) {
                temp = temp.getLeft();
            }
            //输出当前结点
            System.out.println(temp);
            //在向右边都是后继结点那么就一直输出
            while(temp.getRightType() == 0) {
                temp = temp.getRight();
                System.out.println(temp);
            }
            //替换这个遍历的结点
            temp = temp.getRight();
        }
    }

}

class threadNode {
    private int ID;
    private char Code;
    //左结点
    private threadNode left;
    //右节点
    private threadNode right;
    //左指针的状态，因为在线索二叉树里，left和right指针会指向前后驱结点，坐着左右子节点，所以要确定他们到底代表什么意思
    private int leftType = 1;
    //右指针的状态，我们默认设定1时为左右子节点，0时为前后驱结点,所以要将这些type的初始值设为1
    private int rightType = 1;
    public threadNode(int id , char code) {
        ID = id;
        Code = code;
    }
    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 int getID() {
        return ID;
    }

    public void setID(int ID) {
        this.ID = ID;
    }

    public char getCode() {
        return Code;
    }

    public void setCode(char code) {
        Code = code;
    }

    public threadNode getLeft() {
        return left;
    }

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

    public threadNode getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "Node{" +
                "ID=" + ID +
                ", Code=" + Code +
                '}';
    }
}
一只叮铛
关注
HashMap红黑树树化过程，看这一篇就够了
wildyuhao的博客
08-28 1098
HashMap红黑树树化过程，看这一篇就够了红黑树基础概念红黑树性质红黑树示意图红黑树数据结构JDK1.8 HashMap源码分析putVal（）treeifyBin（）treeNode（）treeify（）moveRootToFront（）rotateLeft（）rotateRight（）balanceInsertion（）左旋、右旋过程详细解析 上一篇文章大厂面试爱问的HashMap死锁问题，看这一篇就够了，我们分析了JDK1.7中Hashmap的部分源码实现，最后说到在JDK1.8的时候HashMap
数据结构与算法复习（Java）：排序、字符串、数组、链表、二分查找、二叉树.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
数据结构中的哈希表和二叉树
05-09
这个关于数据结构中的哈希表和二叉树的实现，使用C++实现，那么希望能够对学习数据结构中这个知识点的朋友有帮助
二叉树、哈希表
KinboSong的博客
03-16 4126
二叉树 最优二叉树（哈夫曼树），如何构造哈夫曼树 平衡二叉树 完全二叉树 正则二叉树 二叉树的遍历：前序遍历、中序遍历、后序遍历 Huffman编码
【Java数据结构与算法】第十章 哈希表和二叉树
313YPHU3的博客
07-23 336
【Java数据结构与算法】第十章 哈希表和二叉树
数据结构-哈希表-树
m0_57124899的博客
11-28 871
数据结构哈希表哈希表(散列)-Google 上机题哈希表的基本介绍google 公司的一个上机题:树结构的基础部分二叉树为什么需要树这种数据结构树示意图二叉树的概念尚硅谷 Java 数据结构和算法二叉树遍历的说明 哈希表 哈希表(散列)-Google 上机题 看一个实际需求，google 公司的一个上机题: 有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,住址…),当输入该员工的 id 时,要求查 找到该员工的 所有信息. 3) 要求: 不使用数据库,尽量节省内存,速度越快越好
面试中，经常要用到的数据结构（链表、队列、栈、二叉树、哈希表等）以及一些常用的算法
01-14
5. **哈希表**：哈希表是一种通过哈希函数快速定位数据的数据结构，实现高效查找。Java的`HashMap`和`HashSet`都是基于哈希表实现的。 接下来，我们探讨一些常用的算法： 1. **排序算法**： - **归并排序**：采用...
数据结构域算法-二叉树的查找
最新发布
05-08
虽然提供的部分内容涉及静态查找表及哈希表，但为了贴合标题“数据结构与算法-二叉树的查找”，我们将集中讨论二叉树的基本概念及其查找算法。 ### 二叉树的基本概念 二叉树是一种树形数据结构，其中每个节点最多...
数据结构与算法基础（java版）.zip
07-10
在这个Java版的数据结构与算法课程中，我们将深入探讨以下几个核心概念： 1. **单链表**：单链表是一种线性数据结构，其中每个元素（节点）包含数据以及指向下一个节点的引用。通过Java编程，你可以学习如何创建、...
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、...
HashMap 树化细节
过客看海的博客
01-19 880
链表长度大于8且tab长度大于64才会树化 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if...
使用哈希表存储二叉树所有结点的父结点的实现方式
向前走
12-03 195
使用哈希表存储二叉树所有结点的父结点的实现方式，并解决 寻找最近公共祖先
Java数据结构第四讲-树/递归/Hash
Jet_qi的博客
04-01 1211
常见数据结构和算法实现(排序/查找/数组/链表/栈/队列/树/递归/海量数据处理/图/位图/Java版数据结构) 数据结构和算法作为程序员的基本功，一定得稳扎稳打的学习，我们常见的框架底层就是各类数据结构，例如跳表之于redis、B+树之于mysql、倒排索引之于ES，熟悉了底层数据结构，对框架有了更深层次的理解，在后续程序设计过程中就更能得心应手。掌握常见数据结构和算法的重要性显而易见，本文主要讲解了几种常见的数据结构及基础的排序和查找算法，最后对高频算法笔试面试题做了总结。本文是Java数据结构第四讲
【通用编程】哈希表、搜索树、堆
孟知之的搬砖填坑历险记
02-08 232
1.哈希表 1.1定义 O(1)的时间复杂度 python中的字典dict就是哈希表。 1.2涉及几个字典的函数用法 enumerate(list)#生成一个有序列，且可迭代的字典 zip() nums = List dict1 = {} # 将列表转换成字典，并计数 for v in nums: dict1[v] = dict1.get(v, 0) + 1 #tems把字典变为可以遍历的...
《Java哈希算法、二叉树和递归的总结》
TAOTAOnice的博客
04-10 198
《Java哈希算法、二叉树和递归的总结》 什么是哈希算法？ 散列表,又叫哈希表，它是基于快速存取的角度设计的，也是一种典型的“空间换时间”的做法。顾名思义，该数据结构可以理解为一个线性表，但是其中的元素不是紧密排列的，而是可能存在空隙。 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键...
顺序表 链表 队列 堆 栈 二叉搜索树 哈希表 图 这些数据结构 的应用场景
xiaov_sen的博客
04-10 1384
链表还可以用于实现待办事项列表，每个节点代表一个待办事项，指向下一个节点的指针代表待办事项的顺序。链表还可以用于实现联系人列表，每个节点代表一个联系人，指向下一个节点的指针代表联系人的顺序。链表可以用于实现购物车，每个节点代表一件商品，指向下一个节点的指针代表购物车中商品的顺序。游戏信息存储：可以使用哈希表来实现游戏信息存储中的索引结构，用于快速查找游戏数据和目录。LRU算法可以用链表和哈希表实现，其中链表用于维护访问顺序，哈希表用于快速查找数据。
数据结构：最小堆/哈希表/二叉树/平衡二叉树/红黑树的意义（什么情况下使用）
xiaopei的博客
11-19 4812
接触堆数据结构是在排序里面讲的，空间复杂度O(1),时间复杂度O(NlogN)，但是在实践中还是不如快速排序（好像快速排序可以更好的利用硬件特性）。堆的意义就在于：最快的找到最大/最小值，在堆结构中插入一个值重新构造堆结构，取走最大/最下值后重新构造堆结构 其时间复杂度为O(logN)，而其他方法最少为O(N).堆实践中用途不在于排序，其主要用在调度算法中，比如优先级调度，每次取优先级最高的，时间
哈希表
qq_38353700的博客
10-07 1414
一，简介 哈希表，又称散列表，是一种容器，它的底层一般是数组实现，它可以快速定位一个元素，具有O(1)的时间复杂度。说到这就不得不提，哈希表的原理：哈希表是采用了函数映射的原理，设有函数f(x) （x>=0），则对于任意一个数m(m>=0) ,则有key=f(m),其中key值便是数组中的下标（key>=0）,则f(x)便称为哈希函数,在查找一个元素的时候我们便可以通过哈希函数，找到该元素所在的下
常见数据结构应用场景
weixin_30335353的博客
10-05 1867
通用数据结构 可以简单的按照速度将通用数据结构划分为：数组和链表（最慢），树（较快），哈希表（最快）。增、删、改、查是四大常见操作，不过其实可以浓缩为两个操作：增和查。删除操作和和修改操作都是建立在查找操作上的，所以完美的数据结构应该是具有较高的插入效率和查找效率。 通用数据结构关系 可以根据下图选择合适的通用数据结构： 数组 使用场景 数组在以下三个情形下很有用： 1）数据量较...
数据结构课程设计：平衡二叉树与图算法实战
学生需设计数据结构来存储航班信息，如使用链表或哈希表等，便于快速检索和更新。查询功能需要利用高效的搜索算法，如二分查找或散列表查找。订票和退票功能涉及并发控制和数据一致性问题，学生将运用到队列和锁等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值