精华内容
下载资源
问答
  • 查找排序习题

    2020-10-30 11:57:44
    之前有位读者给我留言,印象深刻,他说:"放弃不,但坚持一定酷!"所以,,坚持下去吧! 今天来讲2个查找排序的习题吧。 1. 题目1: 给定两个字符串s和t,判断t是否为s重新排列后组成单词 例如: s = ‘blue’ ...

    查找排序习题

    数据结构已经介绍完了,我很庆幸自己坚持下来了!之前有位读者给我留言,印象很深刻,他说:"放弃不难,但坚持一定很酷!"所以,,坚持下去吧!
    今天来讲2个查找排序的习题吧。

    1. 题目1:

    给定两个字符串s和t,判断t是否为s重新排列后组成的单词
    例如:
    s = ‘blue’ t = ‘lube’ return true
    s = ‘blue’ t = ‘bull’ return false
    思路很简单,代码也很简单,我把思路都写在代码里了:

    '''
    TOPIC: 查找排序习题1
    author: Blue
    time: 2020-08-08
    QQ: 2458682080
    '''
    
    def isAnagram(s, t):
        """
        :param s: str
        :param t: str
        :return: bool
        """
        
        # 法一: 先排序,后比较  选择排序,时间复杂度O(nlogn)
        # ss = list(s)
        # tt = list(t)
        # ss.sort()
        # tt.sort()
        # return ss == tt
    
        # 法二: 先排序,后比较
        # return sorted(list(s)) == sorted(list(t))
    
        # 法三: 用字典保存两个字符串里字母出现的数量  时间复杂度O(n)
        dict1 = {}
        dict2 = {}
        for ch in s:
            # 如果ch在键里,则+1,如果不在键里,则获取ch为键,并数量+1
            dict1[ch] = dict1.get(ch, 0) + 1  # 如果不存在,则返回0再加1for ch in t:
            dict2[ch] = dict2.get(ch, 0) + 1
        return dict2 == dict1
    
    
    s = 'blue'
    t1 = 'lube'
    t2 = 'bull'
    print(isAnagram(s, t1))
    print(isAnagram(s, t2))
    
    
    # 方法介绍: 
    # dict.get(key, default=None)
    # key -- 字典中要查找的键。
    # default -- 如果指定键的值不存在时,返回该默认值。
    # 返回值: 返回指定键的值,如果键不在字典中返回默认值 None 或者设置的默认值。
    

    结果为:

    True
    False
    

    2. 题目2

    给定一个m*n的二维列表,查找一个数是否存在,列表有以下特性:

    1. 每一行的列表从左到右已经排好序
    2. 每一行第一个数比上一行最后一个数大,即列表本身有序
      例如:
      [
      [1, 3, 5, 7],
      [10, 11, 13, 15],
      [18, 21, 23, 25]
      ]

    代码:

    def searchMatrix(matrix, target):
        """
        :param matrix: list[list[int]]
        :param target: int
        :return: bool
        """
        
        # 法一:线性查找    时间复杂度0(mn)
        # for line in matrix:
        #     if target in line:
        #         return True
        # return False
    
        # 法二: 二分查找 时间复杂度O(logn)
        h = len(matrix)     # 长
        if h == 0:
            return False
        w = len(matrix[0])  # 宽
        if w == 0:
            return False
        left = 0
        right = w * h - 1  # 列表整体长度为 w * h
    
        while left <= right:   # 候选区有值
            mid = (left + right) // 2
            # 获取二维列表中数值的下标
            i = mid // w
            j = mid % w
            if matrix[i][j] == target:
                return True
            elif matrix[i][j] > target:
                right = mid - 1
            else:
                left = mid + 1
        else:
            return False
    
    m = [
        [1, 3, 5, 7],
        [10, 11, 13, 15],
        [18, 21, 23, 25]
    ]
    print(searchMatrix(m, 13))
    

    结果为:True

    展开全文
  • 每年十一月各大IT公司都不约而同、争后恐后地到各大高校进行全国巡回招聘。与此同时,网上也开始出现大量笔试面试;网上流传的题目往往都精巧,既能让考查基础知识...这是一道似易实难的题目,一般同学最容易中的陷
    每年十一月各大IT公司都不约而同、争后恐后地到各大高校进行全国巡回招聘。与此同时,网上也开始出现大量笔试面试题;网上流传的题目往往都很精巧,既能让考查基础知识,又在平淡中隐含了广阔的天地供优秀学生驰骋。
           这两天在网上淘到一道笔试题目(注1),虽然真假未知,但的确是道好题,题目如下:
           从10亿个浮点数中找出最大的1万个。
    这是一道似易实难的题目,一般同学最容易中的陷阱就是没有重视这个“亿”字。因为有10亿个单精度浮点数元素的数组在32位平台上已经达到3.7GB之巨,在常见计算机平台(如Win32)上声明一个这样的数组将导致堆栈溢出。正确的解决方法是分治法,比如每次处理100万个数,然后再综合起来。不过这不是本文要讨论的主旨,所以本文把上题的10亿改为1亿,把浮点数改为整数,这样可以直接地完成这个问题,有利于清晰地讨论相关算法的优化(注2)。
    不假思索
           拿到这道题,马上就会想到的方法是建立一个数组把1亿个数装起来,然后用for循环遍历这个数组,找出最大的1万个数来。原因很简单,因为如果要找出最大的那个数,就是这样解决的;而找最大的1万个数,只是重复1万遍而已。
    template< class T >
    void solution_1( T BigArr[], T ResArr[] )
    {
           for( int i = 0; i < RES_ARR_SIZE; ++i )
           {
                  int idx = i;
                  for( int j = i+1; j < BIG_ARR_SIZE; ++j )
                  {
                         if( BigArr[j] > BigArr[idx] )
                                idx = j;
                  }
                  ResArr[i] = BigArr[idx];
                  std::swap( BigArr[idx], BigArr[i] );
           }
    }
    设BIG_ARR_SIZE = 1亿,RES_ARR_SIZE = 1万,运行以上算法已经超过40分钟(注3),远远超过我们的可接受范围。
    稍作思考
    从上面的代码可以看出跟SelectSort算法的核心代码是一样的。因为SelectSort是一个O(n^2)的算法(solution_1的时间复杂度为O(n*m),因为solution_1没有将整个大数组全部排序),而我们又知道排序算法可以优化到O(nlogn),那们是否可以从这方面入手使用更快的排序算法如MergeSor、QuickSort呢?但这些算法都不具备从大至小选择最大的N个数的功能,因此只有将1亿个数按从大到小用QuickSort排序,然后提取最前面的1万个。
    template< class T, class I >
    void solution_2( T BigArr[], T ResArr[] )
    {
           std::sort( BigArr, BigArr + BIG_ARR_SIZE, std::greater_equal() );
           memcpy( ResArr, BigArr, sizeof(T) * RES_ARR_SIZE );
    }
    因为STL里的sort算法使用的是QuickSort,在这里直接拿来用了,是因为不想写一个写一个众人皆知的QuickSort代码来占篇幅(而且STL的sort高度优化、速度快)。
           对solution_2进行测试,运行时间是32秒,约为solution_1的1.5%的时间,已经取得了几何数量级的进展。
    深入思考
           压抑住兴奋回头再仔细看看solution_2,你将发现一个大问题,那就是在solution_2里所有的元素都排序了!而事实上只需找出最大的1万个即可,我们不是做了很多无用功吗?应该怎么样来消除这些无用功?
           如果你一时没有头绪,那就让我慢慢引导你。首先,发掘一个事实:如果这个大数组本身已经按从大到小有序,那么数组的前1万个元素就是结果;然后,可以假设这个大数组已经从大到小有序,并将前1万个元素放到结果数组;再次,事实上这结果数组里放的未必是最大的一万个,因此需要将前1万个数字后续的元素跟结果数组的最小的元素比较,如果所有后续的元素都比结果数组的最小元素还小,那结果数组就是想要的结果,如果某一后续的元素比结果数组的最小元素大,那就用它替换结果数组里最小的数字;最后,遍历完大数组,得到的结果数组就是想要的结果了。
    template< class T >
    void solution_3( T BigArr[], T ResArr[] )
    {
           //取最前面的一万个
           memcpy( ResArr, BigArr, sizeof(T) * RES_ARR_SIZE );
           //标记是否发生过交换
           bool bExchanged = true;
           //遍历后续的元素
           for( int i = RES_ARR_SIZE; i < BIG_ARR_SIZE; ++i )
           {
                  int idx;
                  //如果上一轮发生过交换
                  if( bExchanged )
                  {
                         //找出ResArr中最小的元素
                         int j;
                         for( idx = 0, j = 1; j < RES_ARR_SIZE; ++j )
                         {
                                if( ResArr[idx] > ResArr[j] )
                                       idx = j;
                         }
                  }
                  //这个后续元素比ResArr中最小的元素大,则替换。
                  if( BigArr[i] > ResArr[idx] )
                  {
                         bExchanged = true;
                         ResArr[idx] = BigArr[i];
                  }
                  else
                         bExchanged = false;
           }
    }
           上面的代码使用了一个布尔变量bExchanged标记是否发生过交换,这是一个前文没有谈到的优化手段——用以标记元素交换的状态,可以大大减少查找ResArr中最小元素的次数。也对solution_3进行测试一下,结果用时2.0秒左右(不使用bExchanged则高达32分钟),远小于solution_2的用时。
    深思熟虑
           在进入下一步优化之前,分析一下solution_3的成功之处。第一、solution_3的算法只遍历大数组一次,即它是一个O(n)的算法,而solution_1是O(n*m)的算法,solution_2是O(nlogn)的算法,可见它在本质上有着天然的优越性;第二、在solution_3中引入了bExchanged这一标志变量,从测试数据可见引入bExchanged减少了约99.99%的时间,这是一个非常大的成功。
           上面这段话绝非仅仅说明了solution_3的优点,更重要的是把solution_3的主要矛盾摆上了桌面——为什么一个O(n)的算法效率会跟O(n*m)的算法差不多(不使用bExchanged)?为什么使用了bExchanged能够减少99.99%的时间?带着这两个问题再次审视solution_3的代码,发现bExchanged的引入实际上减少了如下代码段的执行次数:
    for( idx = 0, j = 1; j < RES_ARR_SIZE; ++j )
    {
           if( ResArr[idx] > ResArr[j] )
                  idx = j;
    }
    上面的代码段即是查找ResArr中最小元素的算法,分析它可知这是一个O(n)的算法,到此时就水落石出了!原来虽然solution_3是一个O(n)的算法,但因为内部使用的查找最小元素的算法也是O(n)的算法,所以就退化为O(n*m)的算法了。难怪不使用bExchanged使用的时间跟solution_1差不多;这也从反面证明了solution_3被上面的这一代码段导致性能退化。使用了bExchanged之后因为减少了很多查找最小元素的代码段执行,所以能够节省99.99%的时间!
    展开全文
  • 文章目录缘起正文二扩展1 生成组织树2.查询时间段交集数据总结 缘起 不久前,我去一家创业公司面试,因为他们没有专业的...在远程口试中,对方问到了两个简单的排序,我觉得这两个排序虽然简单,但有意思。因为

    缘起

    不久前,我去一家创业公司面试,因为他们没有专业的java开发,于是请了一个颇有经验的人出了两道笔试题:1.二分查找的代码实现,2.谈谈关于软件设计原则的看法。也是比较难较难得了,很少有人会问到这些方面,特别是设计原则这块,有很多开发者都不了解这方面的知识。而第一题是很容易,但要是撸一串代码也会为难一批有十年以经验的开发者了(当然我还是有这个自信的)。
    在远程口试中,对方问到了两个简单的排序,我觉得这两个排序虽然简单,但很有意思。因为两道题目很相似,但解法确有些异差。

    正文

    题一

    给定三个数组:
    数组a,长度m;
    数组b,长度n;
    数组c长度m+n;
    其中a与b存放了有序的数据,c为空数组,要求将a与了组合放入c中,且让c为有序数组。跟我以前见过的面试题很相似
    以下是伪代码的实现示例:

    int pa=0,pb=0,pc=0;//指向数组a,b,c的三个指针;
    while(pa<a.lenght && pb < b.lenght){
    	if(a[pa]<=b[pb]){
    		c[pc] = p[pa++];
    	}else{
    		c[pc]=p[pb++]
    	}
    	pc++;
    }
    if(pa<a.a.lenght){
    	arrayCopy(a,pa,(a.lenght-pa),c);// 将a中剩余的数组考贝到c中
    }else if(pb <b.lenght){
    	arrayCopy(b,pb,(b.lenght-pb),c);// 将b中剩余的数组考贝到c中
    }
    
    

    题二

    给定两数组:
    a:长度n,已存放n个有序数。
    b:长度(m+n),其中从0至m-1中已存放两个有序序列
    要求:将a中的数据拷贝到B中,且保持B为有序。

    两题看起来很相似,但其实解法有些不同,题一我们设了三个指针,且按顺序移动,如果题二也按类似实现,那会让b中的数据整体移动(可以参考一下插入排序),于是采用逆序方式
    伪代码如下:

    int pa = n-1;  //指向a的指针
    int pb = m -1 ; //指向b的指针
    int putNext = a+b -1; 下一个在存放位置的指针
    while(pa >=0 && pb >=0){
    	if(a[pa]>= b[pb]){
    		b[putNext] = a[pa];
    		pa--;
    	}else{
    		b[putNext] = b[pb];
    		pb--;
    	}
    	putNext--;
    }
    
    if(pa != 0){
    	...
    }else if(pb != 0){
    	....
    }
     
    

    扩展

    1 生成组织树

    有人会问,这种算法题对自己的工作真的有帮助吗?或能没有帮助,但养成一好思维模式很重要。比如我在工作中见到这样的需求,有这样一张组织表:

    id 名称 层级 父id
    1 总部 0 0
    2 上海总部 1 1
    3 北京总部 1 1
    4 上海技术部 2 2
    5 上海销售部 2 2
    5 北京销售部 2 3

    要求输出一颗树,或类似这样的json格式,再或者要和业务数据关联,进行统计分析。我们能有什么解决方案呢,要用递归一次次的查询,或作一次查询,然后递归操作,再或者用类似动态规划的方式用map保存有个节点的引用(这种方式还是蛮好的,以后我会给一个示例代码)?但我们的查询语句写成这样:
    select * from 部门表 order by 层级 asc,父id asc, id asc.
    我们在拼装树时真的需要用到递归吗?用上面的sql语句查询出的数据集已带有某种特性了,我们可以利用这些特性,来选择更优的算法。

    2.查询时间段交集数据

    id 实例开始时间 实例停止时间
    1 220-1-1 00:00 2010-1-3 00:44
    2 220-1-3 00:00 2010-1-4 00:44
    3 220-1-8 00:00 2010-1-20 00:44

    我曾在一家名企与其成员共事过一段时间,有个需求:给一个起始时间以及一个结束时间,查询这段时间类所有运行的实例。也就是给定起始时间与结束时间,查询表中所有交集数据。项目组的SE特别交待:你要考虑很多情况:比如给定的时间段包含了起始时间,或者包含了结束时间,或者记录的时间段段包含了查询的时间……
    如果要按照那样的分析去做,我或许会写一个有一堆or组成的超级语句。
    但只要考虑到表中实例开始时间与实例停止时间 的顺序性,以及查询中所带的顺序性,这个语句只需要一个简单的and.

    总结

    一种特定的算法可能不重要,但思想很重要,要利用你现有数据集的特征,设计出合理的算法,有时能少写代码,有时能提高你程序的性能。

    展开全文
  • 因此,在键或值的基础上排序HashMap是一个很难的面试问题,如果你不知道如何解决的话。下面让我们看看如何解决这个问题。1. HashMap存储每对键和值作为一个Entry对象。例如,给出一个HashMap,MapaMap=newHa...

    Java中HashMap是一种用于存储“键”和“值”信息对的数据结构。不同于Array、ArrayList和LinkedLists,它不会维持插入元素的顺序。

    因此,在键或值的基础上排序HashMap是一个很难的面试问题,如果你不知道如何解决的话。下面让我们看看如何解决这个问题。

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    1. HashMap存储每对键和值作为一个Entry对象。例如,给出一个HashMap,Map aMap = new HashMap();

    键的每次插入,都会有值对应到散列映射上,生成一个Entry 对象。通过使用这个Entry 对象,我们可以根据值来排序HashMap。

    2.创建一个简单的HashMap,并插入一些键和值。ap aMap = new HashMap();

    // adding keys and values        aMap.put("Five", 5);

    aMap.put("Seven", 7);

    aMap.put("Eight", 8);

    aMap.put("One",1);

    aMap.put("Two",2);

    aMap.put("Three", 3);

    3.从HashMap恢复entry集合,如下所示。Set> mapEntries = aMap.entrySet();

    4.从上述mapEntries创建LinkedList。我们将排序这个链表来解决顺序问题。我们之所以要使用链表来实现这个目的,是因为在链表中插入元素比数组列表更快。List> aList = new LinkedList>(mapEntries);

    5.通过传递链表和自定义比较器来使用Collections.sort()方法排序链表。Collections.sort(aList, new Comparator>() {

    @Override            public int compare(Entry ele1,

    Entry ele2) {

    return ele1.getValue().compareTo(ele2.getValue());

    }

    });

    6.使用自定义比较器,基于entry的值(Entry.getValue()),来排序链表。

    7. ele1.getValue(). compareTo(ele2.getValue())——比较这两个值,返回0——如果这两个值完全相同的话;返回1——如果第一个值大于第二个值;返回-1——如果第一个值小于第二个值。

    8. Collections.sort()是一个内置方法,仅排序值的列表。它在Collections类中重载。这两种个方法是public static > void sort(List list)public static  void sort(List list, Comparator super T> c)

    9.现在你已经排序链表,我们需要存储键和值信息对到新的映射中。由于HashMap不保持顺序,因此我们要使用LinkedHashMap。// Storing the list into Linked HashMap to preserve the order of insertion.      Map aMap2 = new LinkedHashMap();

    for(Entry entry: aList) {

    aMap2.put(entry.getKey(), entry.getValue());

    }

    10.完整的代码如下。package com.speakingcs.maps;import java.util.Collections;import java.util.Comparator;import java.util.HashMap;import java.util.LinkedHashMap;import java.util.LinkedList;import java.util.List;import java.util.Map;import java.util.Map.Entry;import java.util.Set;

    public class SortMapByValues {

    public static void main(String[] args) {

    Map aMap = new HashMap();

    // adding keys and values        aMap.put("Five", 5);

    aMap.put("Seven", 7);

    aMap.put("Eight", 8);

    aMap.put("One",1);

    aMap.put("Two",2);

    aMap.put("Three", 3);

    sortMapByValues(aMap);

    }

    private static void sortMapByValues(Map aMap) {

    Set> mapEntries = aMap.entrySet();

    System.out.println("Values and Keys before sorting ");

    for(Entry entry : mapEntries) {

    System.out.println(entry.getValue() + " - "+ entry.getKey());

    }

    // used linked list to sort, because insertion of elements in linked list is faster than an array list.         List> aList = new LinkedList>(mapEntries);

    // sorting the List        Collections.sort(aList, new Comparator>() {

    @Override

    public int compare(Entry ele1,

    Entry ele2) {

    return ele1.getValue().compareTo(ele2.getValue());

    }

    });

    // Storing the list into Linked HashMap to preserve the order of insertion.         Map aMap2 = new LinkedHashMap();

    for(Entry entry: aList) {

    aMap2.put(entry.getKey(), entry.getValue());

    }

    // printing values after soring of map        System.out.println("Value " + " - " + "Key");

    for(Entry entry : aMap2.entrySet()) {

    System.out.println(entry.getValue() + " - " + entry.getKey());

    }

    }

    }

    展开全文
  • 给出球星们能力值、年份、名字,有多个查询,每个查询给出一个年份范围,求出这个范围里能力值从高到低排列前11名球员,如果能力值相同则按年份从低到高排,如果年份仍然相同,则按名字字典序排。...
  • 因为我发现每日一了,总会出现一些加班已经累了(懒得不想动)时候,而且周末有事多做两道都叫做同一天每日一也让我这个强迫症贼难受. 因此![每日一]系列从今天开始变为[随缘一]系列! 来源: ...
  • 使用堆排序.(堆排序的时间复杂度为Onlogn)因为堆排序每次取到都是最大(或是最小)数字,三个相同数字肯定是紧挨着被取出.所以在原先排序算法上,加2个标记记录即可.代码:// 使用堆排序,每次取最大,连续取...
  • 这道让我想起了归并排序,归并排序的通常也是通过递归来实现,思路不,就是每次比较链表1,2头节点,选择值小那一个作为链表3节点进行连接,还是要注意过程中链表不能出现断裂,还要处理链表为空情况,...
  • leetcode刷了9了,一直没有在博客...链表的排序要比数组排序,主要是链表的断链还有重新建立连接。递归需要的时间复杂度为递归的深度为logn 递归排序的思想简单,先把递归的把左面和右面排好序然后在merge ...
  • (链接:https://blog.csdn.net/qq_35644234/article/details/60578189)回到这道,都说了是一道模板,所以肯定不是很难,但是面是非常磨人,不仔仔细细看根本不知道要求什么,样例...
  • 这道看起来啃爹,但是咱们一起来探索一下吧,别看我代码长,其实不难的。先给你讲个 “鬼” 故事,记得先看完故事再看代码,这样会简单。 这道其实在讲一个故事,有个人叫XH[i],如果他跟XH[j]这个人有关系, ...
  • 字节面试 奇偶链表重新排序 昨晚面字节时候写,卡了好久,最后面试官提示我分成三步: 1、把原链表拆分成两个链表 2、把按降序排列那个链表反转 3、归并两个有序列表 被提示之后还是修修补补最后也没写对,...
  • 极角排序,但是这用atan2()很难写,因为atan2()函数返回值是(-π,π)也就是默认按照第四象限到第二象限排序,但是这是逆时针选点,如果一个点在第二象限,一个在第四象限,那么根据atan2()返回值取小点...
  • 因此,在键或值的基础上排序HashMap是一个很难的面试问题,如果你不知道如何解决的话。下面让我们看看如何解决这个问题。1. HashMap存储每对键和值作为一个Entry对象。例如,给出一个HashMap,MapaMap=newHash...
  • 因此,在键或值的基础上排序HashMap是一个很难的面试问题,如果你不知道如何解决的话。下面让我们看看如何解决这个问题。1. HashMap存储每对键和值作为一个Entry对象。例如,给出一个HashMap,MapaMap=newHa...
  • 和153像,但是数组可以有重复元素,所以更 leetcode 第 153 :寻找旋转排序数组中最小值(C++)_qq_32523711博客-CSDN博客 153里面我们可以借助nums[mid]值与nums[0]大小关系来准确判断如何收缩我们...
  • 因此,在键或值的基础上排序HashMap是一个很难的面试问题,如果你不知道如何解决的话。下面让我们看看如何解决这个问题。1. HashMap存储每对键和值作为一个Entry对象。例如,给出一个HashMap,Map aMap = new Ha...
  • Problem Description ...但是,大家也知道,要想做到完全客观,是一件很难的事情。因为选拔的标准本身就很难统一。 为了解决这个难题,我现在把问题作了简化,现在假设每个队员都是二维平面中的一个点,用(xi,yi)
  • 这道我感觉是LintCode里面Topological Sorting里最Pass,虽然思路不,但是多测试用例过不了。 思路:基于topological sorting。每次都要确定queue.size()是1, 并且还要判断是不是跟给出org数组一样。...
  • 但是拓扑排序并不是数字大小之间的排序,而是某些事情之间的顺序有着相互的顺序关系,就好比说你学了c语言基础以后再继续学习更高深的数据结构学完数据结构之后才能够去做一些比较一些的算法 第一个 hdu3342 ...
  • 题目不是很难理解,刚开始想到用map,但stlmap不是很放心,怕超时。于是放心用数组敲了。(事实证明我放心过头了) 刚开始在Vjugde里面提交老SE,我还以为uva又挂了,最近各种挂啊。。。 后来又刷了一过来提交...
  • 这道只要注意细节并不是很难 思路:使用一个足够大一维数组存放每个数及其出现次数_R[i]=j(数字i出现次数为j),接下来将其存储到一个自己写结构体中,使用vector存放,应为要进行排序,简单些一个排序函数...
  • 然后第二点,也是很难想到一点就是,每次前面那个数列和后面再次排列数列相比,多出来 几个数,而这几个数要不是大数,要不是小数,而且后面在排序的时候,前面多出来这几个数是不会变。 所以这里有个辅助...
  • 后缀数组真是好理解阿,我觉得我一辈子都看不懂了。只能靠模板过日子。 这是一篇我觉得博客:https://www.cnblogs.com/zwfymqz/p/8413523.html#_labelTop 题目链接:...
  • Java面试:如何对HashMap按键值排序

    千次阅读 2017-03-10 17:57:25
    因此,在键或值的基础上排序HashMap是一个很难的面试问题,如果你不知道如何解决的话。下面让我们看看如何解决这个问题。 1.创建一个简单的HashMap,并插入一些键和值。 Map aMap = new HashMap(); //adding keys ...
  • 在学习Java基础过程中,泛型绝对算得上是一个比较理解知识点,尤其对于初学者而言,而且就算是已经有基础Java程序员,可能对泛型理解也不是那么透彻,属于那种看了明白,时间长了就忘那种,究其根本,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 745
精华内容 298
关键字:

很难的排序题