算法-求前k个高频词汇

题目链接：692. 前K个高频单词 - 力扣（LeetCode）

题目描述：

给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。

返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率， 按字典顺序 排序。

示例 1：

输入: words = ["i", "love", "leetcode", "i", "love", "coding"], k = 2
输出: ["i", "love"]
解析: "i" 和 "love" 为出现次数最多的两个单词，均为2次。
    注意，按字母顺序 "i" 在 "love" 之前。

示例 2：

输入: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4
输出: ["the", "is", "sunny", "day"]
解析: "the", "is", "sunny" 和 "day" 是出现次数最多的四个单词，
    出现次数依次为 4, 3, 2 和 1 次。

注意：

• 1 <= words.length <= 500
• 1 <= words[i] <= 10
• words[i] 由小写英文字母组成。
• k 的取值范围是 [1, 不同 words[i] 的数量]

进阶：尝试以 O(n log k) 时间复杂度和 O(n) 空间复杂度解决。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

//现场编程题题目内容：
//        给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。
//        返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率， 按字典顺序 排序。
//
//        示例 1：
//
//        输入: words = ["i", "love", "leetcode", "i", "love", "coding"], k = 2
//        输出: ["i", "love"]
//        解析: "i" 和 "love" 为出现次数最多的两个单词，均为2次。
//        注意，按字母顺序 "i" 在 "love" 之前。
//        示例 2：
//
//        输入: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4
//        输出: ["the", "is", "sunny", "day"]
//        解析: "the", "is", "sunny" 和 "day" 是出现次数最多的四个单词，
//        出现次数依次为 4, 3, 2 和 1 次。
//
//        注意：
//
//        1 <= words.length <= 500
//        1 <= words[i] <= 10
//        words[i] 由小写英文字母组成。
//        k 的取值范围是 [1, 不同 words[i] 的数量]
class Solution {
    //字典排序
    public static boolean comPareWord(String s1,String s2)
    {
        //逐个比较
        int L=Math.min(s1.length(),s2.length());
        for(int i=0;i<L;i++)
        {
            if(s1.charAt(i)>s2.charAt(i))
            {
                return true;
            }else if (s1.charAt(i)<s2.charAt(i)) {
                return false;
            }
        }

        return s1.length()>s2.length();
    }
    public static List<String> topKFrequent(String[] words, int k) {

//        给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。
//        返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率， 按字典顺序 排序。
        List<String> resultList=new ArrayList<>();//存储结果
        Map<String,Integer> map=new HashMap<>();//存储每一个单词出现频率
        int L=words.length;
        //存储唯一单词列表，排序使用
        List<String> wordsList=new ArrayList<>();
        //提取频率
        for(int i=0;i<L;i++)
        {
            if(map.containsKey(words[i]))
            {
                //已经存在的频率加1
                map.put(words[i],map.get(words[i])+1);
            }else
            {
                //不存在直接存入
                map.put(words[i],1);
                //存储单词列表
                wordsList.add(words[i]);
            }
        }
        //排序，冒泡加字典规则
        int L1=wordsList.size();
        for(int i=0;i<L1-1;i++)
        {
            for(int j=0;j<L1-1-i;j++)
            {
                //高到低排序
                String tem=wordsList.get(j);
                if(map.get(wordsList.get(j))<map.get(wordsList.get(j+1)))
                {
                    //交换值
                    wordsList.set(j,wordsList.get(j+1));
                    wordsList.set(j+1,tem);
                }else if(map.get(wordsList.get(j))==map.get(wordsList.get(j+1))){

                    if(comPareWord(wordsList.get(j),wordsList.get(j+1)))
                    {
                        //交换值
                        wordsList.set(j,wordsList.get(j+1));
                        wordsList.set(j+1,tem);
                    }
                }
            }
        }
        //提取前k个值
        for(int i=0;i<k;i++)
        {
            resultList.add(wordsList.get(i));
        }
        //获取前k个频率最多的
        return resultList;

    }

//    public static void main(String[] args) {
//        //"aaa","aa","a"
//        String[] a=new String[]{"aaa","aa","a"};
//        System.out.println(topKFrequent(a,2));
//    }
}

完整一体化代码：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

//现场编程题题目内容：
//        给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。
//        返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率， 按字典顺序 排序。
//
//        示例 1：
//
//        输入: words = ["i", "love", "leetcode", "i", "love", "coding"], k = 2
//        输出: ["i", "love"]
//        解析: "i" 和 "love" 为出现次数最多的两个单词，均为2次。
//        注意，按字母顺序 "i" 在 "love" 之前。
//        示例 2：
//
//        输入: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4
//        输出: ["the", "is", "sunny", "day"]
//        解析: "the", "is", "sunny" 和 "day" 是出现次数最多的四个单词，
//        出现次数依次为 4, 3, 2 和 1 次。
//
//        注意：
//
//        1 <= words.length <= 500
//        1 <= words[i] <= 10
//        words[i] 由小写英文字母组成。
//        k 的取值范围是 [1, 不同 words[i] 的数量]
class Solution {
    public static List<String> topKFrequent(String[] words, int k) {
//        给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。
//        返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率， 按字典顺序 排序。
        List<String> resultList=new ArrayList<>();//存储结果
        Map<String,Integer> map=new HashMap<>();//存储每一个单词出现频率
        int L=words.length;
        //存储唯一单词列表，排序使用
        List<String> wordsList=new ArrayList<>();
        //提取频率
        for(int i=0;i<L;i++)
        {
            if(map.containsKey(words[i]))
            {
                //已经存在的频率加1
                map.put(words[i],map.get(words[i])+1);
            }else
            {
                //不存在直接存入
                map.put(words[i],1);
                //存储单词列表
                wordsList.add(words[i]);
            }
        }
        //排序，冒泡加字典规则
        int L1=wordsList.size();
        for(int i=0;i<L1-1;i++)
        {
            for(int j=0;j<L1-1-i;j++)
            {
                //高到低排序
                String tem=wordsList.get(j);
                if(map.get(wordsList.get(j))<map.get(wordsList.get(j+1)))
                {
                    //交换值
                    wordsList.set(j,wordsList.get(j+1));
                    wordsList.set(j+1,tem);
                }else {
                    //相等的情况按字典排序,按照字典排序，小序号的在前面{先按首字母来比较，如果需要更精确则继续向下比较}
                    //需要依次比较其它位数的结果
                    if(map.get(wordsList.get(j))==map.get(wordsList.get(j+1)))
                    {
                        //交换标志,
                        boolean flag=false;

                        //a 4,b 5
                        //["aaa","aa","a"],空排在前面，以最短的单词来控制顺序
                        int minL=Math.min(wordsList.get(j).length(),wordsList.get(j+1).length());
//                    System.out.println(minL);
                        //在最短长度内能比较出结果，交换
                        for(int w=0;w<minL;w++)
                        {
                            //从前往后比较，如果符合情况，中断
                            if(wordsList.get(j).charAt(w)>wordsList.get(j+1).charAt(w))
                            {
                                System.out.println(wordsList.get(j));
                                System.out.println(wordsList.get(j+1));
                                //进行交换
                                wordsList.set(j,wordsList.get(j+1));
                                wordsList.set(j+1,tem);
                                flag=true;
                                break;
                            }else if(wordsList.get(j).charAt(w)<wordsList.get(j+1).charAt(w))
                            {
                                flag=true;
                                break;
                            }
                        }
                        //不能就通过长度判断
                        if(!flag)
                        {
                            System.out.println(1);
                            if(wordsList.get(j).length()>wordsList.get(j+1).length())
                            {
                                //                        //进行交换
                                wordsList.set(j,wordsList.get(j+1));
                                wordsList.set(j+1,tem);
                            }

                        }
                    }
                }

            }
        }
        //提取前k个值
        for(int i=0;i<k;i++)
        {
            resultList.add(wordsList.get(i));
        }
        //获取前k个频率最多的
        return resultList;

    }

//    public static void main(String[] args) {
//        String[] a=new String[]{"i","love","leetcode","i","love","coding"};
//        System.out.println(topKFrequent(a,2));
        System.out.println('l'>'i');
//    }
}