wy的leetcode刷题记录_Day85

于 2024-03-13 09:07:40 发布
阅读量839 收藏 26
点赞数 22
文章标签： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_54015435/article/details/136641700
版权
本文分享了作者在LeetCode上的刷题经历，包括1261.在受污染的二叉树中查找元素，使用BFS和DFS策略；622和641设计循环队列与循环双端队列，以及705和706设计哈希集合和哈希映射，通过实例展示了如何实现和优化这些数据结构。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

wy的leetcode刷题记录_Day85

声明

本文章的所有题目信息都来源于leetcode
如有侵权请联系我删掉!
时间：2024-3-12

前言

目录

1261. 在受污染的二叉树中查找元素

今天的每日一题是：1261. 在受污染的二叉树中查找元素

题目介绍

示例 1：
在这里插入图片描述

输入： [“FindElements”,“find”,“find”] [[[-1,null,-1]],[1],[2]]
输出：[null,false,true]
解释：
FindElements findElements = new FindElements([-1,null,-1]);
findElements.find(1); // return False
findElements.find(2); // return True

示例 2：

在这里插入图片描述

输入： [“FindElements”,“find”,“find”,“find”][[[-1,-1,-1,-1,-1]],[1],[3],[5]]
输出： [null,true,true,false]
解释：
FindElements findElements = new FindElements([-1,-1,-1,-1,-1]);
findElements.find(1); // return True
findElements.find(3); // return True
findElements.find(5); // return False

示例 3：

在这里插入图片描述

输入： [“FindElements”,“find”,“find”,“find”,“find”][[[-1,null,-1,-1,null,-1]],[2],[3],[4],[5]]
输出：[null,true,false,false,true]
解释：
FindElements findElements = newFindElements([-1,null,-1,-1,null,-1]);
findElements.find(2); // returnTrue
findElements.find(3); // return False
findElements.find(4); //return False
findElements.find(5); // return True

思路

简单的模拟题，根据题意我们先要将数进行重建这里可以使用BFS或DFS重新建立起完整的树，本来我想的是建立起的树就是二叉搜索树可以直接根据根节点向下遍历，但是我发现题目中的参数并没有跟树有关的的任意节点所以应该是需要额外的空间来记录出现的值，而题中所给出的值也都较为简单可以直接使用数组来解决，但通常应使用哈希表。

代码

BFS:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class FindElements {
public:
    unordered_set<int> sett;
    FindElements(TreeNode* root) {

        queue<TreeNode*> q;
        root->val=0;
        q.push(root);
        while(!q.empty())
        {
            int n=q.size();
            for(int i=0;i<n;i++)
            {
                TreeNode* node=q.front();
                sett.insert(node->val);
                q.pop();
                if(node->left)
                {
                    node->left->val=node->val*2+1;
                    q.push(node->left);
                }                
                if(node->right)
                {
                    node->right->val=node->val*2+2;
                    q.push(node->right);
                }

            }
        }

    }
    
    bool find(int target) {
        return sett.count(target)>0;
    }
};

/**
 * Your FindElements object will be instantiated and called as such:
 * FindElements* obj = new FindElements(root);
 * bool param_1 = obj->find(target);
 */

DFS:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

class FindElements {
public:
    unordered_set<int> sett;
    void dfs(TreeNode *node,int val)
    {
        if(node==nullptr)
            return ;
        
        node->val=val;
        sett.insert(node->val);
        dfs(node->left,val*2+1);
        dfs(node->right,val*2+2);
    }

    FindElements(TreeNode* root) {

        dfs(root,0);

    }
    
    bool find(int target) {
        return sett.count(target)>0;
    }
};

/**
 * Your FindElements object will be instantiated and called as such:
 * FindElements* obj = new FindElements(root);
 * bool param_1 = obj->find(target);
 */

收获

巩固了BFS和DFS

622. 设计循环队列

622. 设计循环队列

题目介绍

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。

示例：
MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1); // 返回 true
circularQueue.enQueue(2); // 返回 true
circularQueue.enQueue(3); // 返回 true
circularQueue.enQueue(4); // 返回 false，队列已满
circularQueue.Rear(); // 返回 3
circularQueue.isFull(); // 返回 true
circularQueue.deQueue(); // 返回true
circularQueue.enQueue(4); // 返回 true
circularQueue.Rear(); // 返回 4

思路

考察最基本的循环队列的构建问题，我们可以采用一个数组或者是链表来解决问题，这里为了更直观我们采用数组来解决问题。第一个问题：为了解决循环的问题我们需要头尾俩个指针，每当指针超过capacity时我们就要对指针进行循环（求余）；第二个问题：如果头尾指针都指向对应的首节点和尾节点那么当首节点和尾节点指向同一位置到底是满队列还是空队列？这时采用头指针指向头节点而尾指针指向下一次尾节点该插入的地方。这样判断队满就是看尾指针在进行以此插入后是否与头节点相同（(rear+1)%capacity==front）。因此我们需要比正常给出的队列长度+1个容量来解决。

代码

class MyCircularQueue {
public:
    vector<int> q;
    int i=0;
    int j=0;
    int capacity=0;
    MyCircularQueue(int k) {
        q.resize(k+1);        
        capacity=k+1;
    }
    
    bool enQueue(int value) {
        if(isFull())
            return false;
        q[j]=value;
        j=(j+1)%capacity;
        return true;
    }
    
    bool deQueue() {
        if(isEmpty())
        {
            return false;
        }
        i=(i+1)%capacity;
        return true;
        
    }
    
    int Front() {
        if(isEmpty())
            return -1;
        return q[i];
    }
    
    int Rear() {
        if(isEmpty())
            return -1;
        return q[(j-1+capacity)%capacity];
    }
    
    bool isEmpty() {
        return (i==j);
    }
    
    bool isFull() {
        return (i==(j+1)%capacity);
    }
};

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue* obj = new MyCircularQueue(k);
 * bool param_1 = obj->enQueue(value);
 * bool param_2 = obj->deQueue();
 * int param_3 = obj->Front();
 * int param_4 = obj->Rear();
 * bool param_5 = obj->isEmpty();
 * bool param_6 = obj->isFull();
 */

收获

稳固了循环链表的问题。

641. 设计循环双端队列

641. 设计循环双端队列

题目介绍

设计实现双端队列。

实现 MyCircularDeque 类:

  • MyCircularDeque(int k) ：构造函数,双端队列最大为 k 。
  • boolean insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true ，否则返回 false 。
  • boolean insertLast() ：将一个元素添加到双端队列尾部。如果操作成功返回 true ，否则返回 false 。
  • boolean deleteFront() ：从双端队列头部删除一个元素。 如果操作成功返回 true ，否则返回 false 。
  • boolean deleteLast() ：从双端队列尾部删除一个元素。如果操作成功返回 true ，否则返回 false 。
  • int getFront() )：从双端队列头部获得一个元素。如果双端队列为空，返回 -1 。
  • int getRear() ：获得双端队列的最后一个元素。 如果双端队列为空，返回 -1 。
  • boolean isEmpty() ：若双端队列为空，则返回 true ，否则返回 false 。
  • boolean isFull() ：若双端队列满了，则返回 true ，否则返回 false 。

示例 1：

输入: [“MyCircularDeque”, “insertLast”, “insertLast”, “insertFront”, “insertFront”, “getRear”, “isFull”, “deleteLast”, “insertFront”,“getFront”] [[3], [1], [2], [3], [4], [], [], [], [4], []]
输出: [null,true, true, true, false, 2, true, true, true, 4]

解释: MyCircularDeque circularDeque = new MycircularDeque(3); // 设置容量大小为3
circularDeque.insertLast(1); // 返回 true
circularDeque.insertLast(2); // 返回 true
circularDeque.insertFront(3); // 返回 true
circularDeque.insertFront(4); // 已经满了，返回 false
circularDeque.getRear(); // 返回 2
circularDeque.isFull(); // 返回 true
circularDeque.deleteLast(); // 返回 true
circularDeque.insertFront(4); // 返回 true
circularDeque.getFront(); // 返回 4

思路

在上一题循环队列的基础之上增加了头部插入和头部删除

代码

class MyCircularDeque {
public:
    vector<int> q;
    int front;
    int tail;
    int capacity;

    MyCircularDeque(int k) {
        q=vector<int>(k+1);
        front=tail=0;
        capacity=k+1;
    }
    
    bool insertFront(int value) {
        if(isFull())
            return false;
        front=(front-1+capacity)%capacity;
        q[front]=value;
        return true;
    }
    
    bool insertLast(int value) {
        if(isFull())
            return false;
        q[tail]=value;
        tail=(tail+1)%capacity;
       
        return true;

    }
    
    bool deleteFront() {
        if(isEmpty())
            return false;
        front=(front+1)%capacity;
        return true;

    }
    
    bool deleteLast() {
        if(isEmpty())
            return false;
        tail=(tail-1+capacity)%capacity;
        return true;

    }
    
    int getFront() {
        if(isEmpty())
            return -1;
        return q[front];
    }
    
    int getRear() {
        if(isEmpty())
            return -1;
        return q[(tail-1+capacity)%capacity];
    }
    
    bool isEmpty() {
        return (front==tail);
    }
    
    bool isFull() {
        return (tail+1)%capacity==front;
    }
};

/**
 * Your MyCircularDeque object will be instantiated and called as such:
 * MyCircularDeque* obj = new MyCircularDeque(k);
 * bool param_1 = obj->insertFront(value);
 * bool param_2 = obj->insertLast(value);
 * bool param_3 = obj->deleteFront();
 * bool param_4 = obj->deleteLast();
 * int param_5 = obj->getFront();
 * int param_6 = obj->getRear();
 * bool param_7 = obj->isEmpty();
 * bool param_8 = obj->isFull();
 */

链表解法：

struct DLinkListNode {
    int val;
    DLinkListNode *prev, *next;
    DLinkListNode(int _val): val(_val), prev(nullptr), next(nullptr) {

    }
};

class MyCircularDeque {
private:
    DLinkListNode *head, *tail;
    int capacity;
    int size;

public:
    MyCircularDeque(int k): capacity(k), size(0), head(nullptr), tail(nullptr) {
        
    }

    bool insertFront(int value) {
        if (size == capacity) {
            return false;
        }
        DLinkListNode *node = new DLinkListNode(value);
        if (size == 0) {
            head = tail = node;
        } else {
            node->next = head;
            head->prev = node;
            head = node;
        }
        size++;
        return true;
    }

    bool insertLast(int value) {
        if (size == capacity) {
            return false;
        }
        DLinkListNode *node = new DLinkListNode(value);
        if (size == 0) {
            head = tail = node;
        } else {
            tail->next = node;
            node->prev = tail;
            tail = node;
        }
        size++;
        return true;
    }

    bool deleteFront() {
        if (size == 0) {
            return false;
        }
        DLinkListNode *node = head;
        head = head->next;
        if (head) {
            head->prev = nullptr;
        }
        delete node;
        size--;
        return true;
    }

    bool deleteLast() {
        if (size == 0) {
            return false;
        }
        DLinkListNode *node = tail;
        tail = tail->prev;
        if (tail) {
            tail->next = nullptr;
        }
        delete node;
        size--;
        return true;
    }

    int getFront() {
        if (size == 0) {
            return -1;
        }
        return head->val;
    }

    int getRear() {
        if (size == 0) {
            return -1;
        }
        return tail->val;
    }

    bool isEmpty() {
        return size == 0;
    }

    bool isFull() {
        return size == capacity;
    }
};

收获

简单题

705. 设计哈希集合

705. 设计哈希集合

题目介绍

不使用任何内建的哈希表库设计一个哈希集合（HashSet）。

实现 MyHashSet 类：

  • void add(key) 向哈希集合中插入值 key 。
  • bool contains(key) 返回哈希集合中是否存在这个值 key 。
  • void remove(key) 将给定值 key 从哈希集合中删除。如果哈希集合中没有这个值，什么也不做。

示例：
输入： [“MyHashSet”, “add”, “add”, “contains”, “contains”, “add”,“contains”, “remove”, “contains”] [[], [1], [2], [1], [3], [2], [2], [2], [2]]
输出： [null, null, null, true, false, null, true, null, false]
解释： MyHashSet myHashSet = new MyHashSet();
myHashSet.add(1); //set = [1]
myHashSet.add(2); // set = [1, 2]
myHashSet.contains(1); // 返回 True
myHashSet.contains(3); // 返回 False，（未找到）
myHashSet.add(2); // set = [1, 2]
myHashSet.contains(2); // 返回 True
myHashSet.remove(2); // set = [1]
myHashSet.contains(2);// 返回 False ，（已移除）

思路

使用一个数组来保存哈希表中的数，

  • 对于contains我们只需要遍历数组判断其是否存在即可
  • 对于添加，我们只需要先判断数组是否存在该元素如果不存在那么加入数组，否则不做任何处理。
  • 对于删除，同样先判断数组是否存在该元素如果不存在那么不处理，如果存在的话找到位置直接erase。

代码

class MyHashSet {
public:
    vector<int> HashSet;
    MyHashSet() {

    }
    
    void add(int key) {
        if(contains(key))
            return;
        HashSet.push_back(key);
    }
    
    void remove(int key) {
        if(!contains(key))
            return;
        HashSet.erase(std::remove(HashSet.begin(),HashSet.end(),key));
    }
    
    bool contains(int key) {
        for(auto elem:HashSet)
        {
            if(elem==key)
                return true;
        }
        return false;
    }
};

/**
 * Your MyHashSet object will be instantiated and called as such:
 * MyHashSet* obj = new MyHashSet();
 * obj->add(key);
 * obj->remove(key);
 * bool param_3 = obj->contains(key);
 */

收获

对std里面的remove和vector的erase进行搭配使用。其中全局的remove返回的是没有被删除的最后的一个元素的指针，而erase直接根据该指针将后面的冗余元素全被删除。

706. 设计哈希映射

706. 设计哈希映射

题目介绍

不使用任何内建的哈希表库设计一个哈希映射（HashMap）。

实现 MyHashMap 类：

  • MyHashMap() 用空映射初始化对象
  • void put(int key, int value) 向 HashMap 插入一个键值对 (key, value) 。如果 key 已经存在于映射中，则- - 更新其对应的值 value 。
  • int get(int key) 返回特定的 key 所映射的 value ；如果映射中不包含 key 的映射，返回 -1 。
  • void remove(key) 如果映射中存在 key 的映射，则移除 key 和它所对应的 value 。

示例：

输入： [“MyHashMap”, “put”, “put”, “get”, “get”, “put”, “get”, “remove”, “get”] [[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]]
输出：[null, null, null, 1, -1, null, 1, null, -1]

解释：
MyHashMap myHashMap = new MyHashMap();
myHashMap.put(1, 1); // myHashMap 现在为 [[1,1]]
myHashMap.put(2, 2); // myHashMap 现在为 [[1,1],
[2,2]] myHashMap.get(1); // 返回 1 ，myHashMap 现在为 [[1,1], [2,2]]
myHashMap.get(3); // 返回 -1（未找到），myHashMap 现在为 [[1,1], [2,2]]
myHashMap.put(2, 1); // myHashMap 现在为 [[1,1], [2,1]]（更新已有的值）
myHashMap.get(2); // 返回 1 ，myHashMap 现在为 [[1,1], [2,1]]
myHashMap.remove(2); // 删除键为 2 的数据，myHashMap 现在为 [[1,1]]
myHashMap.get(2); // 返回 -1（未找到），myHashMap 现在为 [[1,1]]

思路

跟上一题的构建奤hashset一样不过这里需要的是键值对，我们使用pair<int,int>来表示键值对，然后与上一篇的做法一致。

代码

class MyHashMap {
public:
    list<pair<int,int>> hash;
    MyHashMap() {

    }
    
    void put(int key, int value) {
        int flag=0;
        for(auto i=hash.begin();i!=hash.end();++i)
        {
            if((*i).first==key)
            {
                (*i).second=value;
                flag=1;
            }
        }
        if(flag==0)
            hash.push_back({key,value});
    }
    
    int get(int key) {
        int n=hash.size();
        for(auto i=hash.begin();i!=hash.end();++i)
        {
            if((*i).first==key)
            {
                return (*i).second;
            }
        }
        return -1;
    }
    
    void remove(int key) {
        for(auto i=hash.begin();i!=hash.end();++i)
        {
            if((*i).first==key)
            {
                hash.erase(i);
                return ;
            }
        }
    }
};

/**
 * Your MyHashMap object will be instantiated and called as such:
 * MyHashMap* obj = new MyHashMap();
 * obj->put(key,value);
 * int param_2 = obj->get(key);
 * obj->remove(key);
 */

收获

简单题

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wy-1226

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值