Leetcode1/242/383-HashMap常用方法以及遍歷排序方式

• 2022 年 4 月 2 日
• 筆記
• LeetCode刷題總結

HashMap常用方法以及遍歷排序方式

常用方法

• map.containsKey()
• map.put()
• map1.equals(map2)

遍歷方式

•    Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
     while (iterator.hasNext()){
          System.out.println(iterator.next());
      }
  

排序方式

• 根據key排序（最好把要排序的設為key）

•     //map對key排序（默認只能對key排序）
      @Test
      public void test1(){
          //普通方式
  //        Map<String, String> map = new TreeMap<>(
  //                new Comparator<String>() {
  //                    public int compare(String obj1, String obj2) {
  //                        //對key降序排序
  //                        return obj2.compareTo(obj1);
  //                    }
  //                });
          //Lambda 表達式
          Map<String,String> map=new TreeMap<>((s1,s2)->{
              return s2.compareTo(s1);
          });
          map.put("d", "ddddd");
          map.put("b", "bbbbb");
          map.put("a", "aaaaa");
          map.put("c", "ccccc");
          Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
          while (iterator.hasNext()){
              System.out.println(iterator.next());
          }
      }
  

• 根據value排序

•     //map對value排序
      //把TreeMap的EntrySet轉換成list，然後使用Collections.sor排序
      @Test
      public void test2(){
          Map<String, String> map = new TreeMap<>();
          map.put("d", "ddddd");
          map.put("b", "bbbbb");
          map.put("a", "eeeee");
          map.put("c", "ccccc");
  
          //這裡將map.entrySet()轉換成list
          List<Map.Entry<String,String>> list = new ArrayList<Map.Entry<String,String>>(map.entrySet());
          //然後通過比較器來實現排序
          Collections.sort(list,new Comparator<Map.Entry<String,String>>() {
              //升序排序
              public int compare(Map.Entry<String, String> o1,
                                 Map.Entry<String, String> o2) {
                  return o1.getValue().compareTo(o2.getValue());
              }
          });
  
          Iterator<Map.Entry<String, String>> iterator = list.iterator();
          while (iterator.hasNext()){
              System.out.println(iterator.next());
          }
      }
  

Leetcode242-有效字母異位詞

• 給定兩個字元串 *s* 和 *t* ，編寫一個函數來判斷 *t* 是否是 *s* 的字母異位詞。
• 注意：若 *s* 和 *t* 中每個字元出現的次數都相同，則稱 *s* 和 *t* 互為字母異位
• 輸入: s = "anagram", t = "nagaram"
• 輸出: true

    public boolean isAnagram(String s, String t) {
            if(s.length()!=t.length()){
                return false;
            }

            Map map1=new HashMap<Character,Integer>();
            Map map2=new HashMap<Character,Integer>();

             for(int i=0;i<s.length();i++){
            if(!map1.containsKey(s.charAt(i))){
                map1.put(s.charAt(i),1);
            }else{
                map1.put(s.charAt(i),(Integer)map1.get(s.charAt(i))+1);
            }
        }

        for(int i=0;i<t.length();i++){
            if(!map2.containsKey(t.charAt(i))){
                map2.put(t.charAt(i),1);
            }else{
                map2.put(t.charAt(i),(Integer)map2.get(t.charAt(i))+1);
            }
        }

        return map1.equals(map2);
    }

Leetcode1-兩數之和

• 給定一個整數數組 nums 和一個整數目標值 target，請你在該數組中找出 和為目標值 target 的那 兩個 整數，並返回它們的數組下標。
• 你可以假設每種輸入只會對應一個答案。但是，數組中同一個元素在答案里不能重複出現。
• 你可以按任意順序返回答案。
• 輸入：nums = [2,7,11,15], target = 9
• 輸出：[0,1]

    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map=new HashMap<>();
        int[] res=new int[2];
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
                res[0]=map.get(target-nums[i]);//get得到value所以這裡把下標作為value
                res[1]=i;
                break;
            }else{
                map.put(nums[i],i);
            }
        }
        return res;
    }

Leetcode383-贖金信

• 給你兩個字元串：ransomNote 和 magazine ，判斷 ransomNote 能不能由 magazine 裡面的字元構成。
• 如果可以，返回 true ；否則返回 false 。
• magazine 中的每個字元只能在 ransomNote 中使用一次。
• 輸入：ransomNote = "a", magazine = "b"
• 輸出：false

    public boolean canConstruct(String ransomNote, String magazine) {

            if(ransomNote.length()>magazine.length()){
                return false;
            }

            Map map=new HashMap<Character,Integer>();

            for(int i=0;i<magazine.length();i++){
                char temp=magazine.charAt(i);
                if(!map.containsKey(temp)){
                    map.put(temp,1);
                }else{
                    map.put(temp,(Integer)map.get(temp)+1);
                }
            }

            for(int j=0;j<ransomNote.length();j++){
                char temp=ransomNote.charAt(j);
                if(map.containsKey(temp)){
                    map.put(temp,(Integer)map.get(temp)-1);
                    if((Integer)map.get(temp)<0){
                        return false;
                    }
                }else{
                    return false;
                }
            }
            
            return true;
    }