leetcode 355-设计推特

已于 2022-09-12 20:42:45 修改
阅读量179 收藏
点赞数
分类专栏： # 数据结构和算法 文章标签： Twitter设计 新闻推送 关注关系 优先级队列 集合排序
于 2022-09-12 20:41:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39542597/article/details/126822386
版权

leetcode 355. 设计推特-https://leetcode.cn/problems/design-twitter/

在这里插入图片描述

class Twitter {

    public Twitter() {

    }
    
    public void postTweet(int userId, int tweetId) {

    }
    
    public List<Integer> getNewsFeed(int userId) {

    }
    
    public void follow(int followerId, int followeeId) {

    }
    
    public void unfollow(int followerId, int followeeId) {

    }
}

方法一

class Twitter0
{

    public static void main(String[] args) {
        Twitter0 Twitter0 = new Twitter0();
        Twitter0.postTweet(1, 5); // 用户 1 发送了一条新推文 (用户 id = 1, 推文 id = 5)
        System.out.println(Twitter0.getNewsFeed(1)); // 用户 1 的获取推文应当返回一个列表，其中包含一个 id 为 5 的推文
        Twitter0.follow(1, 2);    // 用户 1 关注了用户 2
        Twitter0.postTweet(2, 6); // 用户 2 发送了一个新推文 (推文 id = 6)
        System.out.println(Twitter0.getNewsFeed(1)); // 用户 1 的获取推文应当返回一个列表，其中包含两个推文，id 分别为 -> [6, 5] 。推文 id 6 应当在推文 id 5 之前，因为它是在 5 之后发送的
        Twitter0.unfollow(1, 2);  // 用户 1 取消关注了用户 2
        System.out.println(Twitter0.getNewsFeed(1)); // 用户 1 获取推文应当返回一个列表，其中包含一个 id 为 5 的推文。因为用户 1 已经不再关注用户 2
    }

    static Map<Integer, MyInfo> peopleMap;

    static int time;

    public Twitter0() {
        peopleMap = new HashMap<>();
        time = 0;
    }

    public void postTweet(int userId, int tweetId) {
        //推文和时间
        TidAndTime tidAndTime = new TidAndTime(tweetId, getNowTime());
        if (peopleMap.containsKey(userId)) {
            MyInfo myInfo = peopleMap.get(userId);
            myInfo.getTidAndTimeList().add(tidAndTime);
        }
        else {
            //我的信息
            MyInfo myInfo = new MyInfo();
            ArrayList<TidAndTime> tidAndTimeList = new ArrayList<>();
            tidAndTimeList.add(tidAndTime);
            myInfo.setTidAndTimeList(tidAndTimeList);
            peopleMap.put(userId, myInfo);
        }

    }

    //获得最新的推文
    public List<Integer> getNewsFeed(int userId) {
        List<Integer> rtnList = new ArrayList<>();
        if (!peopleMap.containsKey(userId)) {
            return rtnList;
        }

        List<TidAndTime> lastList = new ArrayList<>();
        MyInfo myInfo = peopleMap.get(userId);
        //我的推文和时间
        List<TidAndTime> tidAndTimeList = myInfo.getTidAndTimeList();
        lastList.addAll(tidAndTimeList);
        //我关注的人
        List<Integer> focksList = myInfo.getFocksList();
        //获取我关注人的推文和时间
        List<TidAndTime> focksTidAndTimeList = getfocksFeed(focksList);
        lastList.addAll(focksTidAndTimeList);

        //排序，根据时间获取最新的10条
        boolean change = false;
        for (int i = 0, len = lastList.size(); i < len - 1; i++) {
            for (int j = 0; j < len - i - 1; j++) {
                TidAndTime tidAndTime = lastList.get(j);
                TidAndTime tidAndTime2 = lastList.get(j + 1);
                if (tidAndTime.getTime() < tidAndTime2.getTime()) {
                    lastList.set(j, tidAndTime2);
                    lastList.set(j + 1, tidAndTime);
                    change = true;
                }
            }

            if (!change) {
                break;
            }
        }

        int size = lastList.size();
        if (size > 10) {
            size = 10;
        }

        for (int i = 0; i < size; i++) {
            rtnList.add(lastList.get(i).getTweetId());
        }

        return rtnList;
    }

    public void follow(int followerId, int followeeId) {
        //谁 关注了 谁
        if (peopleMap.containsKey(followerId)) {
            MyInfo myInfo = peopleMap.get(followerId);
            if (!myInfo.getFocksList().contains(followeeId)) {
                myInfo.getFocksList().add(followeeId);
            }
        }
        else {
            MyInfo myInfo = new MyInfo();
            ArrayList<Integer> focksList = new ArrayList<>();
            focksList.add(followeeId);
            myInfo.setFocksList(focksList);
            peopleMap.put(followerId, myInfo);
        }
    }

    public void unfollow(int followerId, int followeeId) {
        //谁 关注了 谁
        if (peopleMap.containsKey(followerId)) {
            MyInfo myInfo = peopleMap.get(followerId);
            List<Integer> focksList = myInfo.getFocksList();
            if (focksList.contains(followeeId)) {
                List<Integer> newForks = new ArrayList<>();
                for (Integer integer : focksList) {
                    if (!integer.equals(followeeId)) {
                        newForks.add(integer);
                    }
                }
                myInfo.setFocksList(newForks);
            }
        }
    }

    //获得关注人的的推文
    public static List<TidAndTime> getfocksFeed(List<Integer> userIdList) {
        List<TidAndTime> rtnList = new ArrayList<>();

        if (userIdList == null || userIdList.isEmpty()) {
            return rtnList;
        }

        for (Integer userId : userIdList) {
            if (!peopleMap.containsKey(userId)) {
                continue;
            }

            MyInfo myInfo = peopleMap.get(userId);
            //我的推文和时间
            rtnList.addAll(myInfo.getTidAndTimeList());
        }
        return rtnList;
    }

    public static long getNowTime() {
        return time++;
    }

    class MyInfo
    {
        //我的发布
        private List<TidAndTime> tidAndTimeList;

        //关注的人
        private List<Integer> focksList;

        public MyInfo() {
            tidAndTimeList = new ArrayList<>();
            focksList = new ArrayList<>();
        }

        public List<TidAndTime> getTidAndTimeList() {
            return tidAndTimeList;
        }

        public void setTidAndTimeList(List<TidAndTime> tidAndTimeList) {
            this.tidAndTimeList = tidAndTimeList;
        }

        public List<Integer> getFocksList() {
            return focksList;
        }

        public void setFocksList(List<Integer> focksList) {
            this.focksList = focksList;
        }
    }

    //tid和发布时间
    class TidAndTime
    {

        private int tweetId;
        private long time;

        public TidAndTime(int tweetId, long time) {
            this.tweetId = tweetId;
            this.time = time;
        }

        public int getTweetId() {
            return tweetId;
        }

        public void setTweetId(int tweetId) {
            this.tweetId = tweetId;
        }

        public long getTime() {
            return time;
        }

        public void setTime(long time) {
            this.time = time;
        }
    }
}

方法2-优先级队列

class Twitter2
{

    public static void main(String[] args) {
        Twitter2 Twitter2 = new Twitter2();
        Twitter2.postTweet(1, 5); // 用户 1 发送了一条新推文 (用户 id = 1, 推文 id = 5)
        System.out.println(Twitter2.getNewsFeed(1)); // 用户 1 的获取推文应当返回一个列表，其中包含一个 id 为 5 的推文
        Twitter2.follow(1, 2);    // 用户 1 关注了用户 2
        Twitter2.postTweet(2, 6); // 用户 2 发送了一个新推文 (推文 id = 6)
        System.out.println(Twitter2.getNewsFeed(1)); // 用户 1 的获取推文应当返回一个列表，其中包含两个推文，id 分别为 -> [6, 5] 。推文 id 6 应当在推文 id 5 之前，因为它是在 5 之后发送的
        Twitter2.unfollow(1, 2);  // 用户 1 取消关注了用户 2
        System.out.println(Twitter2.getNewsFeed(1)); // 用户 1 获取推文应当返回一个列表，其中包含一个 id 为 5 的推文。因为用户 1 已经不再关注用户 2
    }

    static Map<Integer, MyInfo> peopleMap;

    static int time;

    public Twitter2() {
        peopleMap = new HashMap<>();
        time = 0;
    }

    public void postTweet(int userId, int tweetId) {
        //推文和时间
        TidAndTime tidAndTime = new TidAndTime(tweetId, getNowTime());
        MyInfo myInfo = peopleMap.getOrDefault(userId, new MyInfo());
        myInfo.getTidAndTimeList().add(tidAndTime);
        peopleMap.putIfAbsent(userId, myInfo);
    }

    //获得最新的推文
    public List<Integer> getNewsFeed(int userId) {
        List<Integer> rtnList = new ArrayList<>();
        if (!peopleMap.containsKey(userId)) {
            return rtnList;
        }
        PriorityQueue<TidAndTime> queue = new PriorityQueue<>((o1, o2) -> -(o1.getTime() - o2.getTime()));
        MyInfo myInfo = peopleMap.get(userId);
        //我的推文和时间
        List<TidAndTime> tidAndTimeList = myInfo.getTidAndTimeList();
        for (TidAndTime tidAndTime : tidAndTimeList) {
            queue.offer(tidAndTime);
        }
        //我关注的人
        Set<Integer> focksSet = myInfo.getFocksSet();
        //获取我关注人的推文和时间
        List<TidAndTime> focksTidAndTimeList = getfocksFeed(focksSet);
        for (TidAndTime tidAndTime : focksTidAndTimeList) {
            queue.offer(tidAndTime);
        }
        while (!queue.isEmpty() && rtnList.size() < 10) {
            rtnList.add(queue.poll().getTweetId());
        }
        return rtnList;
    }

    public void follow(int followerId, int followeeId) {
        //谁 关注了 谁
        MyInfo myInfo = peopleMap.getOrDefault(followerId, new MyInfo());
        myInfo.getFocksSet().add(followeeId);
        peopleMap.putIfAbsent(followerId, myInfo);
    }

    public void unfollow(int followerId, int followeeId) {
        //谁 关注了 谁
        MyInfo myInfo = peopleMap.get(followerId);
        if (myInfo != null) {
            myInfo.getFocksSet().remove(followeeId);
        }
    }

    //获得关注人的的推文
    public static List<TidAndTime> getfocksFeed(Set<Integer> userIdSet) {
        List<TidAndTime> rtnList = new ArrayList<>();

        if (userIdSet == null || userIdSet.isEmpty()) {
            return rtnList;
        }

        for (Integer userId : userIdSet) {
            if (!peopleMap.containsKey(userId)) {
                continue;
            }

            MyInfo myInfo = peopleMap.get(userId);
            //我的推文和时间
            rtnList.addAll(myInfo.getTidAndTimeList());
        }
        return rtnList;
    }

    public static int getNowTime() {
        return time++;
    }

    class MyInfo
    {
        //我的发布
        private List<TidAndTime> tidAndTimeList;

        //关注的人
        private Set<Integer> focksSet;

        public MyInfo() {
            tidAndTimeList = new ArrayList<>();
            focksSet = new HashSet<>();
        }

        public List<TidAndTime> getTidAndTimeList() {
            return tidAndTimeList;
        }

        public void setTidAndTimeList(List<TidAndTime> tidAndTimeList) {
            this.tidAndTimeList = tidAndTimeList;
        }

        public Set<Integer> getFocksSet() {
            return focksSet;
        }

        public void setFocksSet(Set<Integer> focksSet) {
            this.focksSet = focksSet;
        }
    }

    //tid和发布时间
    class TidAndTime
    {

        private int tweetId;
        private int time;

        public TidAndTime(int tweetId, int time) {
            this.tweetId = tweetId;
            this.time = time;
        }

        public int getTweetId() {
            return tweetId;
        }

        public void setTweetId(int tweetId) {
            this.tweetId = tweetId;
        }

        public int getTime() {
            return time;
        }

        public void setTime(int time) {
            this.time = time;
        }
    }
}

方法三-集合排序，比较器

class Twitter3
{

   static Map<Integer, MyInfo> peopleMap;

    static int time;

    public Twitter3() {
        peopleMap = new HashMap<>();
        time = 0;
    }

    public void postTweet(int userId, int tweetId) {
        //推文和时间
        TidAndTime tidAndTime = new TidAndTime(tweetId, getNowTime());
        MyInfo myInfo = peopleMap.getOrDefault(userId, new MyInfo());
        myInfo.getTidAndTimeList().add(tidAndTime);
        peopleMap.putIfAbsent(userId, myInfo);
    }

    //获得最新的推文
    public List<Integer> getNewsFeed(int userId) {
        List<Integer> rtnList = new ArrayList<>();
        if (!peopleMap.containsKey(userId)) {
            return rtnList;
        }

        List<TidAndTime> lastList = new ArrayList<>();
        MyInfo myInfo = peopleMap.get(userId);
        //我的推文和时间
        List<TidAndTime> tidAndTimeList = myInfo.getTidAndTimeList();
        lastList.addAll(tidAndTimeList);
        //我关注的人
        Set<Integer> focksSet = myInfo.getFocksSet();
        //获取我关注人的推文和时间
        List<TidAndTime> focksTidAndTimeList = getfocksFeed(focksSet);
        lastList.addAll(focksTidAndTimeList);

        Collections.sort(lastList, new Comparator<TidAndTime>()
        {
            @Override
            public int compare(TidAndTime o1, TidAndTime o2) {
                return -(o1.getTime() - o2.getTime());
            }
        });

        int size = lastList.size();
        if (size > 10) {
            size = 10;
        }

        for (int i = 0; i < size; i++) {
            rtnList.add(lastList.get(i).getTweetId());
        }

        return rtnList;
    }

    public void follow(int followerId, int followeeId) {
        //谁 关注了 谁
        MyInfo myInfo = peopleMap.getOrDefault(followerId, new MyInfo());
        myInfo.getFocksSet().add(followeeId);
        peopleMap.putIfAbsent(followerId, myInfo);
    }

    public void unfollow(int followerId, int followeeId) {
        //谁 关注了 谁
        MyInfo myInfo = peopleMap.get(followerId);
        if (myInfo != null) {
            myInfo.getFocksSet().remove(followeeId);
        }
    }

    //获得关注人的的推文
    public static List<TidAndTime> getfocksFeed(Set<Integer> userIdSet) {
        List<TidAndTime> rtnList = new ArrayList<>();

        if (userIdSet == null || userIdSet.isEmpty()) {
            return rtnList;
        }

        for (Integer userId : userIdSet) {
            if (!peopleMap.containsKey(userId)) {
                continue;
            }

            MyInfo myInfo = peopleMap.get(userId);
            //我的推文和时间
            rtnList.addAll(myInfo.getTidAndTimeList());
        }
        return rtnList;
    }

    public static int getNowTime() {
        return time++;
    }

    class MyInfo
    {
        //我的发布
        private List<TidAndTime> tidAndTimeList;

        //关注的人
        private Set<Integer> focksSet;

        public MyInfo() {
            tidAndTimeList = new ArrayList<>();
            focksSet = new HashSet<>();
        }

        public List<TidAndTime> getTidAndTimeList() {
            return tidAndTimeList;
        }

        public void setTidAndTimeList(List<TidAndTime> tidAndTimeList) {
            this.tidAndTimeList = tidAndTimeList;
        }

        public Set<Integer> getFocksSet() {
            return focksSet;
        }

        public void setFocksSet(Set<Integer> focksSet) {
            this.focksSet = focksSet;
        }
    }

    //tid和发布时间
    class TidAndTime
    {

        private int tweetId;
        private int time;

        public TidAndTime(int tweetId, int time) {
            this.tweetId = tweetId;
            this.time = time;
        }

        public int getTweetId() {
            return tweetId;
        }

        public void setTweetId(int tweetId) {
            this.tweetId = tweetId;
        }

        public int getTime() {
            return time;
        }

        public void setTime(int time) {
            this.time = time;
        }
    }
}
YHH学JAVA
关注
专栏目录
【LeetCode Python实现】355. 设计推特（中等）
05-06 243
文章目录题目描述实现 Twitter 类：示例：输入输出提示：参考代码 题目描述 设计一个简化版的推特(Twitter)，可以让用户实现发送推文，关注/取消关注其他用户，能够看见关注人（包括自己）的最近 10 条推文。 实现 Twitter 类： Twitter() 初始化简易版推特对象 void postTweet(int userId, int tweetId) 根据给定的 tweetId 和 userId 创建一条新推文。每次调用此函数都会使用一个不同的 tweetId 。 List getNew
JAVA进步一点点--leetcode设计题型-Map
qq_45759288的博客
03-25 173
学习思路 在leetcode中，设计题型并没有给出一个像数组、字符串等完全一致的一个讲解学习步骤，但是设计题型自我感觉是 数据结构+算法的一种结合，因此，仍然打算按照数据结构的类型来刷题学习。 Map字典类的设计题 Map接口：双列数据，存储key-value对的数据，通过IDEA查看基本类的继承关系，可以看到我们常用Map的类关系如下，选择数据结构，还是需要了解数据结构的特点，我将从键值特点、是否排序、使用范围、线程安全、执行效率几个方面对几个类进行选择。 ...
Java实现 LeetCode 355 设计推特
热门推荐
南 墙
03-10 1万+
355. 设计推特 设计一个简化版的推特(Twitter)，可以让用户实现发送推文，关注/取消关注其他用户，能够看见关注人（包括自己）的最近十条推文。你的设计需要支持以下的几个功能： postTweet(userId, tweetId): 创建一条新的推文 getNewsFeed(userId): 检索最近的十条推文。每个推文都必须是由此用户关注的人或者是用户自己发出的。推文必须按照时间顺序由最近...
leetcode355
剑似生平
02-19 168
class Twitter { private: vector<pair<int,int>>all;//all tweets map<int,vector<int>>mp; public: /** Initialize your data structure here. */ Twitter() { ...
LeetCode 355. Design Twitter
zhaohaibo的博客
01-06 325
题目链接：Design Twitter - LeetCode Design a simplified version of Twitter where users can post tweets, follow/unfollow another user and is able to see the 10 most recent tweets in the user’s news feed. Yo...
leetcode-355. 设计推特
kangbin825的专栏
05-10 199
设计一个简化版的推特(Twitter)，可以让用户实现发送推文，关注/取消关注其他用户，能够看见关注人（包括自己）的最近 10 条推文。 实现 Twitter 类： Twitter() 初始化简易版推特对象 void postTweet(int userId, int tweetId) 根据给定的 tweetId 和 userId 创建一条新推文。每次调用此函数都会使用一个不同的 tweetId 。 List getNewsFeed(int userId) 检索当前用户新闻推送中最近  10 条推
Leetcode 355：设计推特
weixin_35338624的博客
06-30 237
题目描述 设计一个简化版的推特(Twitter)，可以让用户实现发送推文，关注/取消关注其他用户，能够看见关注人（包括自己）的最近十条推文。你的设计需要支持以下的几个功能： postTweet(userId, tweetId): 创建一条新的推文 getNewsFeed(userId): 检索最近的十条推文。每个推文都必须是由此用户关注的人或者是用户自己发出的。推文必须按照时间顺序由最近的开始...
leetcode答案-leetcode:leetcode习题答案
06-30
如"Design Twitter"（设计推特），需要理解并应用到队列、栈以及哈希表等数据结构，同时还需要考虑并发和时间复杂度的问题，这对于提升系统设计能力非常有帮助。 此开源答案集合不仅包含了具体的代码实现，还通常...
leetcode同类骰子-Algorithms:LeetCode，GeeksforGeeks
07-06
leetcode 学生骰子算法 LeetCode，GeeksforGeeks 第一周——图 133, ...355，设计推特 659，将数组拆分成连续的子序列 692，前K个常用词 补充 如何使用 7 面骰子模拟 5 面骰子？ 以及如何做到这一点？
[leetcode] 355. Design Twitter 解题报告
小榕流光的专栏
06-15 2503
题目链接：https://leetcode.com/problems/design-twitter/ Design a simplified version of Twitter where users can post tweets, follow/unfollow another user and is able to see the 10 most recent tweets in
LeetCode 355 - 设计推特
Aries_young的博客
04-14 284
题目描述 355. 设计推特 解法：哈希表+单链表+堆（C++） 其实设计类问题都不难解，主要是想明白采用什么样的数据结构 int global_Time = 0; // 发表推文的时间 // 推文类 class Tweet{ public: int id; int time; Tweet* next; Tweet(int id){ this-&g...
​LeetCode刷题实战355：设计推特
程序IT圈
08-17 394
算法的重要性，我就不多说了吧，想去大厂，就必须要经过基础知识和业务逻辑面试+算法面试。所以，为了提高大家的算法能力，这个公众号后续每天带大家做一道算法题，题目就从LeetCode上面选 ！...
Leetcode 355. Design Twitter
sundawei2016的博客
07-01 251
Design a simplified version of Twitter where users can post tweets, follow/unfollow another user and is able to see the 10 most recent tweets in the user's news feed. Your design should support the
leetcode题解-355. Design Twitter
呜呜哈的博客
03-03 685
题目：Design a simplified version of Twitter where users can post tweets, follow/unfollow another user and is able to see the 10 most recent tweets in the user’s news feed. Your design should support the
leetcode 355. Design Twitter
yaoct的博客
12-17 209
Design a simplified version of Twitter where users can post tweets, follow/unfollow another user and is able to see the 10 most recent tweets in the user's news feed. Your design should support the fo...
[leetcode]355. Design Twitter
曲径通幽处
09-02 716
题目链接：https://leetcode.com/problems/design-twitter/ 题意：这是一个设计类题目，本题要求设计一个Twitter，主要支持以下几种操作：发表一条状态 postTweet(userId, tweetId) 关注某个用户 follow(followerId, followeeId): Follower follows a followee 对某个用户取消关注
leetcode：355. 设计推特
OceanStar的博客
08-10 135
下面这种方法和上面的基本一样，就是在保存用户所有消息的时候，用的是 vector，这样可以用 priority_queue 来帮助找出最新 10 条消息。
算法---设计推特(Kotlin)
男儿不展风云志，空有天生八尺躯
04-22 1213
题目： 设计一个简化版的推特(Twitter)，可以让用户实现发送推文，关注/取消关注其他用户，能够看见关注人（包括自己）的最近 10 条推文。 实现 Twitter 类： Twitter() 初始化简易版推特对象 void postTweet(int userId, int tweetId) 根据给定的 tweetId 和 userId 创建一条新推文。每次调用此函数都会使用一个不同的 tweetId 。 List getNewsFeed(int userId) 检索当前用户新闻推送中最近 10 条推文
idea leetcode-edito乱码
最新发布
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值