精华内容
下载资源
问答
  • 查找专题查找的概念查找表操作⽅方式分类(静态/...总结动态查找表二叉排序树(Binary Sort Tree)⼆二叉排序树(Binary Sort Tree) — 树结构定义二叉排序树(Binary Sort Tree) — 查找操作代码实现二叉排序树(Binary Sort

    查找的概念

    查找(Searching): 就是根据给定的某个值,在查找表中确定⼀一个其关键字等于给定值 的数据元素。
    **查找表(Search Table)**是由同一类型的数据元素(记录)构成的集合。
    **关键字(Key)**是数据元素中某个数据项的值.又称为键值. ⽤用它可 以表示一个数据元素,也可以标识一个记录的某个数据项(字段). 我们称为关键码。
    若关键字可以唯一地标识一个记录, 则称此关键字为主关键字 (Primary Key)。
    对于那些可以识别多个属于元素(记录)的关键字,我们称为次关键 字(Secondary Key)。

    查找表操作⽅方式分类(静态/动态)

    静态查找表(Static Search Table): 只作查找操作的查找表;

    1. 查询某个”特定的”数据元素是否在查找表中;

    2. 检索某个"特定的"数据元素和各种属性;

    动态查找表(Dynamic Search Table): 在查找过程中同时插⼊入查找表中不不存在的数据元素, 或者从查找表中删除已经存在的某个数据元素; 显然动态查找表的操作就是2个动作。

    1. 查找时插⼊数据元素;
    2. 查找时删除数据元素;

    顺序表查找(Sequential Search)

    顺序查找(Sequential Search), 又称为线性查找. 是最基本的查找技术. 它的查找过程: 从表中的第一个(或最后一个)记录开始,逐个进行记录关键 字和给定值比较;

    1. 若某个记录的关键字和给定值相等,则查找成功,找到所查记录;
    2. 如果直到最后一个(或第一个)记录, 其关键字和给定值比较都不等 时, 则表中没有所查的记录,查找不成功;
    代码实现
    //1.顺序查找
    //a为数组,n为查找的数组个数,key为要查找的关键字;
    int Sequential_Search(int *a,int n,int key){
        for (int i = 1; i <= n ; i++)
            if (a[i] == key)
                return i;
       
        return 0;
    }
    
    优化(增加哨兵,将key存储在a[0])
    //2.顺序查找_哨兵
    int Sequential_Search2(int *a,int n,int key){
        int i;
        //设置a[0]为关键字值,称为'哨兵'
        a[0] = key;
        //循环从数组尾部开始
        i = n;
        while (a[i] != key) {
            i--;
        }
        //返回0,则说明查找失败
        return i;
    }
    

    折半查找(Binary Search)

    折半查找(Binary Search)技术,又称为二分查找.
    它的前提是线性表中的记录必须是关键码有序(通常是从小到⼤有序),线性表必须采⽤用顺序存储;

    折半查找的基本思想是:

    1. 在有序表中,取中间记录作为⽐较对象,若给定值与中间记录的关键字相 等则查找成功;
    2. 若给定值小于中间的记录关键字,则在中间记录的左半区继续查找;
    3. 若给定的值大于中间记录的关键字,则在中间记录的右半区继续查找;
    4. 不断重复以上的过程,直到查找成功,或所以查找区域⽆记录,查找失败为止.
    代码实现
    //假设数组a,已经是有序的(从小到大)
    int Binary_Search(int *a,int n,int key){
        
        int low,high,mid;
        //定义最低下标为记录首位
        low = 1;
        //定义最高下标为记录末位
        high = n;
        while (low <= high) {
            
            //折半计算
            mid = (low + high) /2;
            
            
            if (key < a[mid]) {
                //若key比a[mid] 小,则将最高下标调整到中位下标小一位;
                high = mid-1;
            }else if(key > a[mid]){
                 //若key比a[mid] 大,则将最低下标调整到中位下标大一位;
                low = mid+1;
            }else
                //若相等则说明mid即为查找到的位置;
                return mid;
        }
        
        return 0;
    }
    
    查找范围优化(插值查找)

    插值查找(Interpolation Search):是根据查找的关键字key 与查找表中最大最⼩记录的关键字⽐比较后的查找方法, 其核心 就是在于插值的计算公式:
    在这里插入图片描述
    #####代码实现

    int Interpolation_Search(int *a,int n,int key){
        int low,high,mid;
        low = 1;
        high = n;
        
        while (low <= high) {
            
            //插值
            mid = low+ (high-low)*(key-a[low])/(a[high]-a[low]);
        
            if (key < a[mid]) {
                //若key比a[mid]插值小,则将最高下标调整到插值下标小一位;
                high = mid-1;
            }else if(key > a[mid]){
                //若key比a[mid]插值 大,则将最低下标调整到插值下标大一位;
                low = mid+1;
            }else
                //若相等则说明mid即为查找到的位置;
                return mid;
        }
        
        return 0;
    }
    

    斐波拉契查找(Fibonacci Search)

    代码实现
    //5.斐波拉契查找
    int F[100]; /* 斐波那契数列 */
    int Fibonacci_Search(int *a,int n,int key){
      
        int low,high,mid,i,k;
        //最低下标为记录的首位;
        low = 1;
        //最高下标为记录的末位;
        high = n;
        k = 0;
        
        //1.计算n为斐波拉契数列的位置;
        while (n > F[k]-1) {
            k++;
        }
        
        //2.将数组a不满的位置补全值;
        for(i = n;i < F[k]-1;i++)
            a[i] = a[n];
        
        //3.
        while (low <= high) {
            
            //计算当前分隔的下标;
            mid = low+F[k-1]-1;
            
            
            if (key < a[mid]) {
                //若查找的记录小于当前分隔记录;
                //将最高下标调整到分隔下标mid-1处;
                high = mid-1;
                //斐波拉契数列下标减1位;
                k = k-1;
                
            }else if(key > a[mid]){
                //若查找的记录大于当前的分隔记录;
                //最低下标调整到分隔下标mid+1处
                low = mid+1;
                //斐波拉契数列下标减2位;
                k = k-2;
                
            }else{
                if (mid <= n) {
                    //若相等则说明,mid即为查找的位置;
                    return mid;
                }else
                {
                    //若mid>n,说明是补全数值,返回n;
                    return n;
                }
            }
        }
        return 0;
    }
    

    有序查找-总结

    这几种查找方式只是每次选择的范围不同,其公式总结如下:
    在这里插入图片描述

    动态查找表

    二叉排序树(Binary Sort Tree)

    二叉排序树(Binary Sort Tree),又称为二叉查找树. 它或者是一颗空树.或者是一颗具有下列性质的二叉树;

    1. 若它的左子树不空,则左子树上所有结点的值均小于它的根结构的值;
    2. 若它的右子树不空,则右子树上的所有结点的值均大于它的根结点的值;
    3. 它的左右子树也分别是二叉排序树;
    ⼆叉排序树(Binary Sort Tree) — 树结构定义

    在这里插入图片描述

    二叉排序树(Binary Sort Tree) — 查找操作代码实现
    //1.二叉排序树--查找
    /*
     递归查找二叉排序树T中,是否存在key;
     指针f指向T的双亲,器初始值为NULL;
     若查找成功,则指针p指向该数据元素的结点,并且返回TRUE;
     若指针p指向查找路径上访问的最后一个结点则返回FALSE;
     */
    Status SearchBST(BiTree T,int key,BiTree f, BiTree *p){
       
        if (!T)    /*  查找不成功 */
        {
            *p = f;
            return FALSE;
        }
        else if (key==T->data) /*  查找成功 */
        {
            *p = T;
            return TRUE;
        }
        else if (key<T->data)
            return SearchBST(T->lchild, key, T, p);  /*  在左子树中继续查找 */
        else
            return SearchBST(T->rchild, key, T, p);  /*  在右子树中继续查找 */
    }
    
    二叉排序树(Binary Sort Tree) — 插入操作代码实现
    //2.二叉排序树-插入
    /*  当二叉排序树T中不存在关键字等于key的数据元素时, */
    /*  插入key并返回TRUE,否则返回FALSE */
    Status InsertBST(BiTree *T, int key) {
        
        BiTree p,s;
        //1.查找插入的值是否存在二叉树中;查找失败则->
        if (!SearchBST(*T, key, NULL, &p)) {
            
            //2.初始化结点s,并将key赋值给s,将s的左右孩子结点暂时设置为NULL
            s = (BiTree)malloc(sizeof(BiTNode));
            s->data = key;
            s->lchild = s->rchild = NULL;
            
            //3.
            if (!p) {
                //如果p为空,则将s作为二叉树新的根结点;
                *T = s;
            }else if(key < p->data){
                //如果key<p->data,则将s插入为左孩子;
                p->lchild = s;
            }else
                //如果key>p->data,则将s插入为右孩子;
                p->rchild = s;
            
            return  TRUE;
        }
        
        return FALSE;
    }
    
    二叉排序树(Binary Sort Tree) — 删除操作
    //3.从二叉排序树中删除结点p,并重接它的左或者右子树;
    Status Delete(BiTree *p){
        
        BiTree temp,s;
        
        
        if((*p)->rchild == NULL){
           
            //情况1: 如果当前删除的结点,右子树为空.那么则只需要重新连接它的左子树;
            //①将结点p临时存储到temp中;
            temp = *p;
            //②将p指向到p的左子树上;
            *p = (*p)->lchild;
            //③释放需要删除的temp结点;
            free(temp);
            
        }else if((*p)->lchild == NULL){
            
            //情况2:如果当前删除的结点,左子树为空.那么则只需要重新连接它的右子树;
            //①将结点p存储到temp中;
            temp = *p;
            //②将p指向到p的右子树上;
            *p = (*p)->rchild;
            //③释放需要删除的temp结点
            free(temp);
        }else{
            
            //情况③:删除的当前结点的左右子树均不为空;
           
            //①将结点p存储到临时变量temp, 并且让结点s指向p的左子树
            temp = *p;
            s = (*p)->lchild;
          
            //②将s指针,向右到尽头(目的是找到待删结点的前驱)
            //-在待删除的结点的左子树中,从右边找到直接前驱
            //-使用`temp`保存好直接前驱的双亲结点
            while (s->rchild) {
                temp = s;
                s = s->rchild;
            }
            
            //③将要删除的结点p数据赋值成s->data;
            (*p)->data = s->data;
            
            //④重连子树
            //-如果temp 不等于p,则将S->lchild 赋值给temp->rchild
            //-如果temp 等于p,则将S->lchild 赋值给temp->lchild
            if(temp != *p)
                temp->rchild = s->lchild;
            else
                temp->lchild = s->lchild;
            
            //⑤删除s指向的结点; free(s)
            free(s);
        }
        
        return  TRUE;
    }
    
    插入删除代码综合
    //4.查找结点,并将其在二叉排序中删除;
    /* 若二叉排序树T中存在关键字等于key的数据元素时,则删除该数据元素结点, */
    /* 并返回TRUE;否则返回FALSE。 */
    Status DeleteBST(BiTree *T,int key)
    {
        //不存在关键字等于key的数据元素
        if(!*T)
            return FALSE;
        else
        {
            //找到关键字等于key的数据元素
            if (key==(*T)->data)
                return Delete(T);
            else if (key<(*T)->data)
                //关键字key小于当前结点,则缩小查找范围到它的左子树;
                return DeleteBST(&(*T)->lchild,key);
            else
                //关键字key大于当前结点,则缩小查找范围到它的右子树;
                return DeleteBST(&(*T)->rchild,key);
            
        }
    }
    
    展开全文
  • 查找动态库位置

    2016-03-10 21:09:00
    时候程序运行在不同的linux发行版本上一个正常,一个出错,引起的原因可能是某个共享库比较老旧,对比它在不同的系统上运行时依赖的库版本就可以知道引起错误可能的原因。那么如何知道一个程序运行时依赖哪些共享...

      有时候程序运行在不同的linux发行版本上一个正常,一个出错,引起的原因可能是某个共享库比较老旧,对比它在不同的系统上运行时依赖的库版本就可以知道引起错误可能的原因。那么如何知道一个程序运行时依赖哪些共享库呢?

    一.查看程序依赖的共享库

    1.使用ldd命令

      首先得了解ldd是用来做什么的,需要注意什么,直接man,

      描述:

          ldd用来打印程序运行时的依赖的共享库,或者打印一个指定的共享库它又依赖于哪些共享库。

      注意事项:

          通常情况下,ldd调用标准的动态链接器(linux下的ld-linux.so.xx,它一般是一个位于/lib目录下的符号链接文件),将环境变量中  LD_TRACE_LOADED_OBJECTS 值为1,看名字就直到,它是控制允许跟踪加载对象的一个变量。但是需要注意的是,某些版本的ldd它获取依赖库信息时是通过直接执行程序的方式。也就是说,你最好不要将ldd用在一个不可信任的可执行程序上,因为这可能会由于执行这个不可信的程序引发安全问题。一个更安全的方法是通过使用objdump来获取信息:

           objdump -p /path/to/program | grep NEEDED 

      常用选项:

           --version
                  Print the version number of ldd.
    
           -v --verbose
                  Print all information, including, for example, symbol versioning information.
    
           -u --unused
                  Print unused direct dependencies.  (Since glibc 2.3.4.)
    
           -d --data-relocs
                  Perform relocations and report any missing objects (ELF only).
    
           -r --function-relocs
                  Perform relocations for both data objects and functions, and report any missing objects or functions (ELF only).
    
           --help Usage information.

     

      注意到上面红色文字,在看看ldd程序的本质:

    thomas@thomas-laptop:~/test/libld$ whereis ldd
    ldd: /usr/bin/ldd /usr/bin/X11/ldd /usr/share/man/man1/ldd.1.gz
    thomas@thomas-laptop:~/test/libld$ file /usr/bin/ldd
    /usr/bin/ldd: Bourne-Again shell script, ASCII text executable

     

      它其实就是一个shell脚本,通过调用ld-linux.so.xx,并将环境变量 LD_TRACE_LOADED_OBJECTS设置为1,使用完毕后,再将这个环境变量unset,对应的其他选项诸如-v -u -d -r都是通过设置 LD_VERBOSE LD_WARN LD_BIND_NOW 这些个环境变量或者它们的组合来实现的,分析下ldd这个脚本就知道了。

     

    2.使用ld-linux.so.x

      可能不同的平台这个文件路径和名字不一样,man下ld.so可以看到详细信息。基本用法:

      ld-linux.so.x  [OPTIONS] [PROGRAM [ARGUMENTS]]

      这里稍微需要注意下,program可以是elf文件,或者一个so库,必须指定其路径,绝对路径或者相对路径均可。主要用的选项是 --list

    3.使用objdump

      objdump可以分析对象文件的信息,或者反汇编对象文件。既然是可以反汇编对象文件,那么可以猜测对象文件必须是包含一堆机器码的文件,所谓object文件,参见wiki上的定义Object file,大致就是说一堆机器码再加一些描述信息,而机器码呢又是relocatable,就是说机器码的各个模块最终在内存中如何分布可以通过描述信息来确定。一般linux下就是elf格式的文件,比如编译形成的可执行文件,*.o *.a *.so ,这一类的文件。

      通过 objdump -p objectfile | grep NEEDED来获得运行时所需共享库。

     

    4. readelf

      objdump用法类似,不过参数是 -d

     

    5.pmap

      只是不知道arm是否可以移植这个命令,它可以查看一个正在运行的进程的内存使用情况,那么也就看到了加载到内存中的共享库,只是它可能看不到完整的依赖库,这要看程序是怎么链接共享库的。共享库分为2种加载方式,1.程序运行前一次性全部加载完毕 2.当程序运行到某个点时,通过调用一些API来加载所需动态库。其实这里的这个动态库和共享库格式无区别,只是加载方式,时间点,不同罢了。如果是采用第一种方式,那么pmap可以看到完整的依赖,若是后者则可能看到的依赖库不完整。

     

    二.查找库的位置

      使用ldconfig -p | grep "your lib",ldconfig也是一个shell脚本,查看这个脚本可以看出真正执行的是ldconfig.real这个文件,它可以获取缓冲在/etc/ld.so.cache中的的库信息。

     

    转载于:https://www.cnblogs.com/thammer/p/5263471.html

    展开全文
  • 有时我们需要知道一个程序依赖哪些动态链接库(DLL)文件。实际上,很多方法可以做到。下面就是三种实现方法: 通过 Visual Studio 的 Dependency Walker 工具。进入 Visual Studio 的命令行(以Visual St...

    原文转自 http://163n.blog.163.com/blog/static/5603555220113151113287/

     

    有时我们需要知道一个程序依赖哪些动态链接库(DLL)文件。实际上,有很多方法可以做到。下面就是三种实现方法:

    1. 通过 Visual Studio 的 Dependency Walker 工具。进入 Visual Studio 的命令行(以Visual Studio 2005 为例,通过“开始-->所有程序-->Microsoft Visual Studio 2005-->Visual Studio Tools-->Visual Studio 2005 Command Prompt” 打开),输入"depends",回车,打开“Dependency Walker”。然后通过“File-->Open”打开要查询的程序文件,Dependency Walker就会显示该程序文件所依赖的 DLL 文件。
    2. 通过金山清理专家。安装金山清理专家,运行要检测的程序,然后打开金山清理专的安全百宝箱中的进程管理器,选中要检测的程序文件名,就选中“显示加载到进程中的DLL”,就可以看到该进程所调用的 DLL 文件。
    3. 借助 IceSword 软件。先运行要检测的程序,然后打开 IceSword 软件,点击进程,找到要检测的程序,并右击该程序名,在弹出的菜单中选择“模块信息”。这时,软件就会弹出“进程模块信息”对话框,这里显示了程序所信赖的 DLL 文件。

    转载于:https://www.cnblogs.com/happykoukou/p/6891185.html

    展开全文
  • linux 查询某个应用的进程都有哪些

    千次阅读 2017-03-07 09:40:34
    查找线程: ps -aux| grep tomcat ps 是progress status的意思,为我们提供了进程的一次性的查看,它所提供的查看结果并不动态连续的; -e 显示所有进程。 -f 全格式。 | 管道命令 grep 筛选信息 kill -9 ...

    查找线程:

    ps -aux| grep tomcat

    ps是progress status的意思,为我们提供了进程的一次性的查看,它所提供的查看结果并不动态连续的;

    -e 显示所有进程。

    -f 全格式。

    | 管道命令

    grep 筛选信息



    kill -9 23324 

    每个进程有一个进程号,这个命令是通过该进程号去删除该进程



    使用场景:当某个应用非正常关闭的时候,其实进程还在,因此再次启动该应用的时候,往往会报错,因此需要把这个应用的相关进程删除掉

    展开全文
  • 原标题:java高级特性是什么集合框架是一套性能优良、使用方便的接口和类(位于java.util包中)解决数组在存储上不能很好适应元素数量动态变化,查找效率低的缺陷集合接口: Map、Collection(子接口List、Set) 、 ...
  • 二叉查找树最大的特点就是,支持动态数据集合的快速插入、删除、查找操作。 我们之前说过,散列表也是支持这些操作的,并且散列表的这些操作比二叉查找树更高效,时间复杂度是 O(1)。既然了这么高效的散列表,...
  • 数据结构-二叉查找

    2019-07-20 23:28:01
    二叉查找树最大的特点就是,支持动态数据集合的快速插入、删除、查找操作。 散列表也是支持这些操作的,并且散列表更加的高效,时间复杂度是O(1)。既然了这么高效的散列表,为什么还需要二叉查找树呢?使用二叉树...
  • 常见的散列函数有哪些?冲突又怎么解决喃?散列表的动态扩容解答+面试题一、散列表(哈希表、Hash 表)不同与之前我们介绍的线性表,所有的数据都是顺序存储,当我们需要在线性表中查找某一数据时,当线性表过长,需要...
  • 项目已的危险权限,想要查找哪些代码使用了   危险权限 WRITE_EXTERNAL_STORAGE 外部存储写入权限 可以查找Environment.getExternalStorageDirectory(),该方法是获取外部存储的路径,但真正需要权限的是...
  • 找到相关的review后,可以看有哪些文章引用了这个review,获得最新动态,一般这样搜出来的都比较新(scholar就支持这样的功能) 找到较新的综述,查看它引用了哪些文章,这些文章就是我们的参考 ...
  • 研究路由器固件时,这个函数调用外部函数库中的 usrGetPass : 切换到固件根目录后: grep -rn "usrGetPass" 匹配出含有 usrGetPass 的文件,第一个是分析的文件,...在 ida 开头也记录需要哪些外部函数库: ...
  • 不同的场景不同的优化方式,总得来说,一般分治,分支界限,贪心,动态规划等思想。 2、循环优化 每种编程语言都会强调需要优化循环。当使用 Python 的时候,你可以依靠大量的技巧使得循...
  • 这篇文章的大体结构如下: 1、对java集合框架一个整体的认识和了解 2、通过继承关系图认识集合的整体框架 3、提前给出各个集合类的使用场景等 认识集合 开发应用程序时,如果想存储多个同类型的...正因为了这些缺陷,
  • 用react做项目时,遇到性能瓶颈时怎么办?...那么此时,我们应该去查找有哪些无用的render?例如:import React from 'react' const list = [ { id: 1, title: '项目 1', }, { id: 2, title: '项目 2', }...
  • 不 BB,直接上干货,非科班出生,毕业工作后才开始学算法,到目前学了 4 年 !...10个算法:递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法。掌握了这...
  • 在【B+树】:MySQL数据库索引是如何实现的?中,我们讲了MySQL数据库索引的实现原理。MySQL底层依赖的是B+树这种数据结构...同时,通过索引这个应用场景,我也带你回顾一下,之前我们学过的几种支持动态集合的数据结...
  • 二叉查找树最大的特点就是:支持动态数据集合的快速插入、删除、查找操作。。。 散列表也是支持这些操作的,并且散列表这些操作比二叉查找树更高效,时间复杂度是O(1)。既然了这么高效的散列表,使用二叉树的地方...
  • 二叉查找树最大的特点就是,支持动态数据集合的快速插入、删除、查找操作。 我们之前说过,散列表也是支持这些操作的,并且散列表的这些操作比二叉查找树更高效,时间复杂度是 O(1)。既然了这么高效的散列表,使用...
  • 二叉查找树最大的特点就是,支持动态数据集合的快速插入、删除、查找操作。 我们之前说过,散列表也是支持这些操作的,并且散列表的这些操作比二叉查找树更高效,时间复杂度是 O(1)。既然了这么高效的散列表,使用...
  • 二叉查找树最大的特点就是,支持动态数据集合的快速插入、删除、查找操作。 我们之前说过,散列表也是支持这些操作的,并且散列表的这些操作比二叉查找树更高效,时间复杂度是 O(1)。既然了这么高效的散列表,...
  • Nebula3学习笔记(4): 工具库

    千次阅读 2008-07-04 14:48:00
    Nebula3工具库, 包含一些工具类, 容器类, 还有一个强大的String类.下面分别来看一下有哪些东东: Array 动态数组, 类似std::vector, 自带了排序方法和二分查找
  • 408问答题复习(七)

    2020-04-10 18:18:23
    数据结构: 1、为什么迪杰斯特拉算法中的图不能有负权值的边?...7、静态查找和动态查找有何区别?分别有什么查找算法? 8、分块查找,即索引顺序查找算法是怎样的? 9、B树与B+树的区别? 10、快速排序的基本...
  • 现实生活中,有很多找东西的例子,比如在学校找某个人,在驿站找快递,在信息登记表上查找某个人的信息,那么在计算机科学中,具体有哪些可以加快查找的算法?下面我们就来看看其中的动态查找算法,动态查找的意思是...
  • 11、EJB是基于哪些技术实现的?并说出SessionBean和EntityBean的区别,StatefulBean和StatelessBean的区别。 EJB包括Session Bean、Entity Bean、Message Driven Bean,基于JNDI、RMI、JAT等技术实现。 SessionBean...
  • Linux进程相关概念

    2020-09-19 23:49:32
    二、如何查看系统中有哪些进程?三、什么是进程标识符?四、什么叫父进程,什么叫子进程?五、C程序的存储空间是如何分配的? 一、什么是程序,什么是进程,有什么区别? 进程是程序的一次执行过程,是动态概念,...
  • 零基础小白PHP开发好学吗,PHP知识点有哪些呢,如果分段学习PHP技术,你所知道的方法有哪些呢?第一阶段2048、扫雷、贪吃蛇游戏项目贯穿 内容管理 文件操作 PL/SQL编程 HTTP服务器开发WEB 数据结构 排序算法 查找...
  • 命名空间 : 静态属性 : 属于类内部的命名空间 动态属性 : 属于类内部的命名空间 对象属性 : 属于对象的,在类内和self发生联系,在类外和对象名发生联系 可以查看静态属性的都有哪些:类名 对象名 可以调用类中的...
  • Map和Set

    2021-02-19 12:20:11
    首先看一下Map和Set具体实现类有哪些; 1.概念和场景 1.Map和Set是一种专门用来搜索的容器或者数据结构,其搜索的效率与具体的实例化子类有关; Map和Set是一种适合动态查找的集合容器; 2.模型:一般把搜索的...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 227
精华内容 90
关键字:

动态查找有哪些