leetcode-python刷题-数据结构篇（未完）

一、队列：先入先出的数据结构

1. FIFO 数据结构：首先处理添加到队列中的第一个元素
   插入–入队，新元素被添加在队列的末尾
   删除–出队，只能移除第一个元素

知识点补充

双边队列

python-deque()

调用前先输入：from collections import deque
内置函数有：
a=deque()
a.append(2)
a.popleft()

c+±#include

使用方法：
dequea;创建一个双端队列a
a.empty();判断队列是否为空
a.push_front(s);将s从队头入队
a.push_back(s);将s从队尾入队
a.front();返回队头元素
a.back();只返回队尾元素
a.pop_front();将队头元素弹出
a.pop_back();将队尾元素弹出
a.clear();将队列清空

题目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

Cpp

class MyCircularQueue {
private:
    vector data;
    int head;
    int tail;
    int size;
public:
    /** Initialize your data structure here. Set the size of the queue to be k. */
    MyCircularQueue(int k) {
        data.resize(k);
        head = -1;
        tail = -1;
        size = k;
    }
    
    /** Insert an element into the circular queue. Return true if the operation is successful. */
    bool enQueue(int value) {
        if (isFull()){
            return false;
        }
        if (isEmpty()){
            head = 0;
        }
        tail = (tail + 1) % size;
        data[tail] = value;
        return true;
    }
    
    /** Delete an element from the circular queue. Return true if the operation is successful. */
    bool deQueue() {
        if (isEmpty()){
            return false;
        }
        if (head == tail){
            head = -1;
            tail = -1;
            return true;
        }
        head = (head + 1) % size;
        return true;
    }
    
    /** Get the front item from the queue. */
    int Front() {
        if(isEmpty()){
            return -1;
        }
        return data[head];
    }
    
    /** Get the last item from the queue. */
    int Rear() {
        if (isEmpty()){
            return -1;
        }
        return data[tail];
    }
    
    /** Checks whether the circular queue is empty or not. */
    bool isEmpty() {
        return head == -1;
    }
    
    /** Checks whether the circular queue is full or not. */
    bool isFull() {
        return ((tail + 1) % size) == head;
    }
};

/**
 * 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();
 */

python

class MyCircularQueue:
    def __init__(self, k: int):
        """
        Initialize your data structure here. Set the size of the queue to be k.
        """
        self._len=k
        self._elems=[0] * self._len
        self._head=0
        self._num=0
    def enQueue(self, value: int) -> bool:
        """
        Insert an element into the circular queue. Return true if the operation is successful.
        """
        if self._num==self._len:
            return False
        else:
            self._elems[(self._head+self._num) % self._len]=value
            self._num+=1
            return True
    def deQueue(self) -> bool:
        """
        Delete an element from the circular queue. Return true if the operation is successful.
        """
        if self._num==0:
            return False
        else:
            self._head=(self._head+1)%self._len
            self._num-=1
            return True
    def Front(self) -> int:
        """
        Get the front item from the queue.
        """
        if self._num==0:
            return -1
        else:
            return self._elems[self._head]
    def Rear(self) -> int:
        """
        Get the last item from the queue.
        """
        if self._num==0:
            return -1
        else:
            return self._elems[(self._head+self._num-1)%self._len]
    def isEmpty(self) -> bool:
        """
        Checks whether the circular queue is empty or not.
        """
        return self._num==0
    def isFull(self) -> bool:
        """
        Checks whether the circular queue is full or not.
        """
        return self._num==self._len
# Your MyCircularQueue object will be instantiated and called as such:
# obj = MyCircularQueue(k)
# param_1 = obj.enQueue(value)
# param_2 = obj.deQueue()
# param_3 = obj.Front()
# param_4 = obj.Rear()
# param_5 = obj.isEmpty()
# param_6 = obj.isFull()

题目346.数据流中的移动平均值

给定一个整数数据流和一个窗口大小，根据该滑动窗口的大小，计算其所有整数的移动平均值。

示例:

MovingAverage m = new MovingAverage(3);
m.next(1) = 1
m.next(10) = (1 + 10) / 2
m.next(3) = (1 + 10 + 3) / 3
m.next(5) = (10 + 3 + 5) / 3

思路：
方法一：数组或列表
size表示设定的实例大小，length表示队列中的大小
用数组或列表来记录所有传入的值，然后从中取出对应的元素来计算平均值

python方法一

class MovingAverage:
    def __init__(self, size: int):
        """
        Initialize your data structure here.
        """
        self.size=size
        self.queue=[]
    def next(self, val: int) -> float:
        size,queue=self.size,self.queue
        queue.append(val)
        length=len(queue)
        if length<=self.size:
            window_sum=sum(queue)
        else:
            window_sum=sum(queue[-size:])
        return window_sum/min(length,size)

简略写法：

class MovingAverage:
    def __init__(self, size: int):
        """
        Initialize your data structure here.
        """
        self.size=size
        self.queue=[]
    def next(self, val: int) -> float:
        size,queue=self.size,self.queue
        queue.append(val)
        window_sum=sum(queue[-size:])
        return window_sum/min(len(queue),size)

惊奇的发现无论queue里边是几个数，如果取比它长度大的倒数几个数始终都是整个queue，如a=[1,2,3],a[-5:]=[1,2,3]

• 时间复杂度：O（N），其中N是移动窗口的大小，每次调用next（val），都需要从queue中检索N个元素
• 空间复杂度：O（M），是queue的大小

python方法二：双端队列

由于不需要存储数据流中的所有值，只需要数据流中的最后n个值。
根据移动窗口的定义，在每个步骤中，向窗口末端添加一个元素，同时从窗口前部删除一个元素。故应用双端队列的数据结构。
在两端删除或添加元素时间复杂度为O（1），空间复杂度为O（N），N为移动窗口的大小

• sum计算时不必遍历全部的窗口，只需要减去前一个，加上后一个即可

注意，使用deque()时候要先在前面加一句from collections import deque,同时可以使用内置函数popleft

from collections import deque
class MovingAverage:
    def __init__(self, size: int):
        """
        Initialize your data structure here.
        """
        self.size=size
        self.queue=deque()
        self.window_sum=0
        self.count=0
    def next(self, val: int) -> float:
        self.count+=1
        self.queue.append(val)
        tail=self.queue.popleft() if self.count>self.size else 0
        self.window_sum=self.window_sum-tail+val
        return self.window_sum/min(self.count,self.size)

一种更简洁的写法

from collections import deque
class MovingAverage:
    def __init__(self, size: int):
        """
        Initialize your data structure here.
        """
        self.size=size
        self.queue=deque()
        self.window_sum=0
        self.count=0
    def next(self, val: int) -> float:
        self.queue.append(val)
        tail=self.queue.popleft() if len(self.queue)>self.size else 0
        self.window_sum=self.window_sum-tail+val
        return self.window_sum/min(len(self.queue),self.size)

执行用时 :68 ms, 在所有 Python3 提交中击败了94.18%的用户
内存消耗 :16.9 MB, 在所有 Python3 提交中击败了5.77%的用户
为了巩固一下cpp不要学了python忘记cpp所以也要写一遍cpp的

cpp双边队列法

class MovingAverage {
private:
    dequedata;
    double window_sum=0;
    int a;
public:
    /** Initialize your data structure here. */
    MovingAverage(int size) {
        a=size;
    }
    
    double next(int val) {
        data.push_back(val);
        if(data.size()>a){
            window_sum=window_sum+val-data.front();
            data.pop_front();
        }
        else{
            window_sum+=val;
        }
        return window_sum/data.size();
    }
};

执行用时 :32 ms, 在所有 C++ 提交中击败了60.68%的用户
内存消耗 :13.3 MB, 在所有 C++ 提交中击败了100.00%的用户

好久没用c++了然后都忘废了，后面加油！

二、队列和BFS

BFS：广度优先搜索
应用：找出从根节点到目标节点的最短路径
结点的处理顺序：越是接近根结点的结点将越早的遍历
BFS 的两个主要方案，遍历或找出最短路径

题目286.墙与门

你被给定一个 m × n 的二维网格，网格中有以下三种可能的初始化值：

-1 表示墙或是障碍物
0 表示一扇门
INF 无限表示一个空的房间。然后，我们用 231 - 1 = 2147483647 代表 INF。你可以认为通往门的距离总是小于 2147483647 的。
你要给每个空房间位上填上该房间到 最近 门的距离，如果无法到达门，则填 INF 即可。

示例：

给定二维网格：

INF -1 0 INF
INF INF INF -1
INF -1 INF -1
0 -1 INF INF
运行完你的函数后，该网格应该变成：

3 -1 0 1
2 2 1 -1
1 -1 2 -1
0 -1 3 4

思路：
就是以门为原点，遍历其周围是INF（房间的）点，然后遍历到的点限制在行列范围内，满足这个条件就加1，同时给他作为新的备选原点，以此类推

class Solution(object):
    def __init__(self):
        # 设定四个遍历方向 
        self.directions = [[0, 1], [1, 0], [0, -1], [-1, 0]]

    def wallsAndGates(self, rooms):
        """
        :type rooms: List[List[int]]
        :rtype: None Do not return anything, modify rooms in-place instead.
        """
        if not rooms: return rooms
        m, n = len(rooms), len(rooms[0])
        # 标记已访问
        marked = [[False for _ in range(n)] for _ in range(m)]

        queue = deque()
        for i in range(m):
            for j in range(n):
                if rooms[i][j] == 0:
                    marked[i][j] = True
                    queue.append((i, j))
                elif rooms[i][j] == -1:
                    marked[i][j] = True
        self.__BFS(queue, rooms, m, n, marked)
        return

    def __BFS(self, queue, rooms, m, n, marked):
        step = 0
        while queue:
            step +=1
            times = len(queue)
            for _ in range(times):
                x, y = queue.popleft()
                for direciton in self.directions:
                    new_x = x + direciton[0]
                    new_y = y + direciton[1]
                    if 0 <= new_x <= m - 1 and 0 <= new_y <= n - 1 and not marked[new_x][new_y]:
                        rooms[new_x][new_y] = step
                        marked[new_x][new_y]= True
                        queue.append((new_x,new_y))

我按照他这个写了一遍可是不知道哪里错了答案一直错
另一种写法

from collections import deque
class Solution:
    def wallsAndGates(self, rooms: List[List[int]]) -> None:
        """
        Do not return anything, modify rooms in-place instead.
        """
        if not rooms:return rooms
        m,n=len(rooms),len(rooms[0])
        queue=deque()
        INF = 2**31-1
        
        for i in range(m):
            for j in range(n):
                if rooms[i][j]==0:
                    queue.append((i,j))
        if len(queue)==0:
            print('no rooms')
            return rooms
        while queue:
            r,c=queue.popleft()
            if r-1 >= 0 and rooms[r-1][c] == INF:
                rooms[r-1][c]=rooms[r][c]+1
                queue.append((r-1,c))
            if r+1 < m and rooms[r+1][c] == INF:
                rooms[r+1][c]=rooms[r][c]+1
                queue.append((r+1,c))
            if c-1 >= 0 and rooms[r][c-1] == INF:
                rooms[r][c-1]=rooms[r][c]+1
                queue.append((r,c-1))
            if c+1 < n and rooms[r][c+1] == INF:
                rooms[r][c+1]=rooms[r][c]+1
                queue.append((r,c+1))
        return rooms

题目200：岛屿数量

给定一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。示例 1:输入:
11110
11010
11000
00000

输出: 1
示例 2:输入:
11000
11000
00100
00011

输出: 3

python-dfs法

思路：
从第一个为1的数开始，按照从上到下从左到右的方向遍历它的四周，在满足边界条件的情况下，将遍历过的全都是1 的数变为零，防止下一次重复遍历，然后使用递归调用，这个步骤完成以后就所有相邻的全为1的数都遍历完成，然后计数加一
接着从剩下的数里边挑选为1 的数开始继续遍历
同时队列中存储的是每次遍历后

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        from collections import deque
        if not grid : return 0
        m,n=len(grid),len(grid[0])
        cnt=0
        self.directions=[[1,0],[-1,0],[0,-1],[0,1]]
        def dfs(i,j):
            grid[i][j]='0'
            for direction in self.directions:
                newx=i+direction[0]
                newy=j+direction[1]
                if 0<=newx

python-bfs法

思路和dfs一样，没什么区别，也用到了递归只是多了个队列的表示，queue即存即取，每次存入调用时的（i，j），用时候直接取出，保证queue里边就一个（i，j），直到queue里边是空的为止

from collections import deque
class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        if not grid : return 0
        m,n=len(grid),len(grid[0])
        cnt = 0
        self.directions=[[1,0],[-1,0],[0,-1],[0,1]]
        def bfs(i,j):
            queue=deque()
            queue.append((i,j))
            while queue:
                x,y=queue.popleft()
                for direction in self.directions:
                    newx=x+direction[0]
                    newy=y+direction[1]
                    if 0<=newx

题目752. 打开转盘锁

你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’ 。每个拨轮可以自由旋转：例如把 ‘9’ 变为 ‘0’，‘0’ 变为 ‘9’ 。每次旋转都只能旋转一个拨轮的一位数字。

锁的初始数字为 ‘0000’ ，一个代表四个拨轮的数字的字符串。

列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。

字符串 target 代表可以解锁的数字，你需要给出最小的旋转次数，如果无论如何不能解锁，返回 -1。

示例 1:

输入：deadends = [“0201”,“0101”,“0102”,“1212”,“2002”], target = “0202”
输出：6
解释：
可能的移动序列为 “0000” -> “1000” -> “1100” -> “1200” -> “1201” -> “1202” -> “0202”。
注意 “0000” -> “0001” -> “0002” -> “0102” -> “0202” 这样的序列是不能解锁的，
因为当拨动到 “0102” 时这个锁就会被锁定。
示例 2:

输入: deadends = [“8888”], target = “0009”
输出：1
解释：
把最后一位反向旋转一次即可 “0000” -> “0009”。
示例 3:

输入: deadends = [“8887”,“8889”,“8878”,“8898”,“8788”,“8988”,“7888”,“9888”], target = “8888”
输出：-1
解释：
无法旋转到目标数字且不被锁定。
示例 4:

输入: deadends = [“0000”], target = “8888”
输出：-1

提示：

死亡列表 deadends 的长度范围为 [1, 500]。
目标数字 target 不会在 deadends 之中。
每个 deadends 和 target 中的字符串的数字会在 10,000 个可能的情况 ‘0000’ 到 ‘9999’ 中产生。
思路：
固定queue中为初始值“0000”以及最开始的步数step，即计数
然后也是设置一个上下加一，同时要把每次遍历过的那个数加进deadends中避免重复便利，同时更换queue

BFS解题思路

一般步骤：先确定一个搜索范围，起始点，标记和目标，然后写出相邻关系函数。先将起始点出列，马上与它相邻点入列，并标记已访问，如此循环，直到列表为空，这样就能一直搜索，直到找到目标点

class Solution:
    def openLock(self, deadends: List[str], target: str) -> int:
        from collections import deque
        deadends=set(deadends)
        
        if '0000' in deadends : return -1
        if target in deadends : return -1
        
        queue=deque()
        queue.append(("0000",0))
        
        while queue:
            node,step = queue.popleft()
            for i in range(4):
                for add in [1,-1]:
                    cur = node[:i] + str((int(node[i])+add)%10) + node[i+1:]
                    if cur == target :
                        return step+1
                    if not cur in deadends :
                        queue.append((cur,step+1))
                        deadends.add(cur)
        return -1

执行用时 :612 ms, 在所有 Python3 提交中击败了91.06%的用户
内存消耗 :14.6 MB, 在所有 Python3 提交中击败了5.63%的用户

题目279.完全平方数

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

示例 1:

输入: n = 12
输出: 3
解释: 12 = 4 + 4 + 4.
示例 2:

输入: n = 13
输出: 2
解释: 13 = 4 + 9.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/perfect-squares
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路：

BFS广度优先遍历

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5y34fMU4-1586704777047)(en-resource://database/1750:1)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cIp8KWs5-1586704777052)(en-resource://database/1754:1)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CGONRm6M-1586704777055)(en-resource://database/1752:1)]

class Solution:
    def numSquares(self, n: int) -> int:
        from collections import deque
        queue=deque()
        queue.append(n)
        step=0
        vis=set()
        while queue:
            step+=1
            l=len(queue)
            for _ in range(l):
                s=queue.popleft()
                for i in range(1,int(s**0.5)+1):
                    cur =s-i**2
                    if cur==0:
                        return step
                    if not cur in vis:
                        queue.append(cur)
                        vis.add(cur)
        return step

动态规划

没看懂。。
思路：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nmgV6xbY-1586704777059)(en-resource://database/1756:1)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zN3z7wve-1586704777062)(en-resource://database/1758:1)]

class Solution:
    def numSquares(self, n: int) -> int:
        dp=[i for i in range(n+1)]
        for i in range(2,n+1):
            for j in range(1,int(i**(0.5))+1):
                dp[i]=min(dp[i],dp[i-j*j]+1)
        return dp[-1]