leetcode 简单题

  1. (leetcode 703) 数据流中的第k大元素

    利用小顶堆

class KthLargest:

    def __init__(self, k: int, nums: List[int]):
        self.k = k
        self.size = len(nums)
        self.nums = nums
        heapq.heapify(self.nums)
        while self.size > k:
            heapq.heappop(self.nums)
            self.size -= 1

    def add(self, val: int) -> int:
        if self.size < self.k:
            heapq.heappush(self.nums,val)
            self.size += 1
        elif val > self.nums[0]:
            heapq.heapreplace(self.nums,val)
        return self.nums[0]
# Your KthLargest object will be instantiated and called as such:
# obj = KthLargest(k, nums)
# param_1 = obj.add(val)

  1. leetcode 20 有效的括号
class Solution:
    def isValid(self, s: str) -> bool:
        if not str:
            return True
        s_dict = {"(":")","{":"}","[":"]"}
        que = []
        for v in s:
            if len(que) > 0:
                if s_dict[que[-1]] == v:
                    que.pop()
                else:
                    if v in s_dict.values():
                        return False
                    que.append(v)
            else:
                if v in s_dict.values():
                    return False
                que.append(v)
        if len(que) ==0:
            return True
        else:
            return False
  1. (leetcode 155)最小栈
class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []
        self.order = []
        self.min = float('inf')
        self.secMin = float('inf')
        self.size = 0
    def push(self, x: int) -> None:
        self.stack.append(x)
        self.size += 1
        self.order = sorted(self.stack)
    def pop(self) -> None:
        if self.size == 0:
            return None
        indx = self.order.index(self.stack[-1])
        del self.stack[-1]
        del self.order[indx]
        self.size -= 1

    def top(self) -> int:
        if self.size == 0:
            return None
        return self.stack[-1]
    def getMin(self) -> int:
        if self.size == 0:
            return None
        return self.order[0]
  1. (leetcode 225) 队列实现栈
class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.stacks = []
        self.size = 0

    def push(self, x: int) -> None:
        """
        Push element x onto stack.
        """
        self.stacks.append(x)
        self.size += 1

    def pop(self) -> int:
        """
        Removes the element on top of the stack and returns that element.
        """
        re = self.stacks[-1]
        del self.stacks[-1]
        self.size -= 1
        return re
    def top(self) -> int:
        """
        Get the top element.
        """
        return self.stacks[-1]

    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        if self.size == 0:
            return True
        return False
  1. (leetcode 496) 下一个更大的元素
class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        result = []
        for v in nums1:
            flag = 0
            indx = nums2.index(v)
            for m in nums2[indx:]:
                if m > v:
                    result.append(m)
                    flag = 1
                    break
            if not flag:
                result.append(-1)
        return result
  1. (leetcode 682) 棒球比赛

    注:题目,思路都很简单,注意要把字符变成数字

class Solution:
    def calPoints(self, ops: List[str]) -> int:
        que = []
        for v in ops:
            if v == "C":
                if len(que) > 0:
                    que.pop()
            else:
                if v != "+" and v!= "D":
                    que.append(int(v))
                else:
                    que.append(v)

        for i,v in enumerate(que):
            if v == "+":
                if i == 0:
                    que[i] = 0
                else:
                    tmp = i-2 if i >2 else 0
                    que[i] = sum(que[tmp:i])
            elif v == "D":
                if i>0:
                    que[i] = 2* que[i-1]
                else:
                    que[i] = 0
        sumr = 0
        for v in que:
            sumr += v
        return sumr
  1. (leetcode 232) 用栈实现队列
class MyQueue:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.que = []
        self.size = 0

    def push(self, x: int) -> None:
        """
        Push element x to the back of queue.
        """
        self.que.append(x)
        self.size += 1

    def pop(self) -> int:
        """
        Removes the element from in front of queue and returns that element.
        """
        tmp = self.que[0]
        del self.que[0]
        self.size -= 1
        return tmp

    def peek(self) -> int:
        """
        Get the front element.
        """
        return self.que[0]

    def empty(self) -> bool:
        """
        Returns whether the queue is empty.
        """
        if self.size ==0:
            return True
        return False
  1. (leetcode 884) 比较含退格的字符串
class Solution:
    def backspaceCompare(self, S: str, T: str) -> bool:

        def delStr(s):
            s1 = []
            for v in s:
                if v == "#":
                    if len(s1) > 0:
                        s1.pop()
                else:
                    s1.append(v)
            return s1

        s1 = delStr(S)
        t1 = delStr(T)
        if s1 == t1:
            return True
        return False

贪心算法

  1. (leetcode 122) 买卖股票的最佳时机
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        sumr = 0
        if len(prices) == 0:
            return 0
        for i in range(1,len(prices)):
            tmp = prices[i] - prices[i-1]
            if tmp > 0:
                sumr += tmp
        return sumr
  1. (leetcode 455) 分发饼干
class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:

        def findIndex(val,indx):
            flag = 0
            for i in range(indx,len(orderS)):
                if orderS[i] >= val:
                    return i
            return len(orderS)

        orderG = sorted(g)
        orderS = sorted(s)
        sumr = 0
        indx = 0
        for i in range(len(orderG)):
            indx = findIndex(orderG[i],indx)
            if indx< len(s):
                sumr += 1
            else:
                break
            indx += 1
        return sumr
  1. (leetcode 860) 柠檬水找零
class Solution:
    def lemonadeChange(self, bills: List[int]) -> bool:
        if not bills:
            return True

        changes = {5:0,10:0}
        for v in bills:
            if v == 5:
                changes[5] += 1
            elif v == 10:
                if changes[5] == 0:
                    return False
                else:
                    changes[5] -= 1
                    changes[10] += 1
            else:
                if changes[5] == 0:
                    return False
                if changes[10] != 0:
                    changes[10] -= 1
                    changes[5] -= 1
                else:
                    if changes[5] < 3:
                        return False
                    changes[5] -= 3
        return True

原文地址:https://www.cnblogs.com/curtisxiao/p/10679145.html

时间: 2024-09-30 06:26:44

leetcode 简单题的相关文章

Leetcode简单题41~60

41.思路:分别在列表中存放两个单词的索引,再用两次遍历求距离# 给定一个单词列表和两个单词 word1 和 word2,返回列表中这两个单词之间的最短距离.# 示例:# 假设 words = ["practice", "makes", "perfect", "coding", "makes"]# 输入: word1 = “coding”, word2 = “practice”# 输出: 3# 输入: wo

Leetcode简单题61~80

61.思路:bin# 编写一个函数,输入是一个无符号整数,返回其二进制表达式中数字位数为 ‘1’ 的个数(也被称为汉明重量).# 示例 1:# 输入:00000000000000000000000000001011# 输出:3# 解释:输入的二进制串 00000000000000000000000000001011 中,共有三位为 '1'.# 示例 2:# 输入:00000000000000000000000010000000# 输出:1# 解释:输入的二进制串 0000000000000000

【leetcode 简单】第十七题 二进制求和

实现 int sqrt(int x) 函数. 计算并返回 x 的平方根,其中 x 是非负整数. 由于返回类型是整数,结果只保留整数的部分,小数部分将被舍去. 示例 1: 输入: 4 输出: 2 示例 2: 输入: 8 输出: 2 说明: 8 的平方根是 2.82842...,   由于返回类型是整数,小数部分将被舍去. #define PF(w) ((w)*(w)) int mySqrt(int x) { int start = 0; int end = x; double mid = 0; i

【leetcode 简单】 第七十题 有效的字母异位词

给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的一个字母异位词. 示例 1: 输入: s = "anagram", t = "nagaram" 输出: true 示例 2: 输入: s = "rat", t = "car" 输出: false 说明: 你可以假设字符串只包含小写字母. 进阶: 如果输入字符串包含 unicode 字符怎么办?你能否调整你的解法来应对这种情况? class Solution:

【leetcode 简单】 第七十一题 二叉树的所有路径

给定一个二叉树,返回所有从根节点到叶子节点的路径. 说明: 叶子节点是指没有子节点的节点. 示例: 输入: 1 / 2 3 5 输出: ["1->2->5", "1->3"] 解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3 # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x

【leetcode 简单】 第七十七题 单词模式

给定一种 pattern(模式) 和一个字符串 str ,判断 str 是否遵循相同的模式. 这里的遵循指完全匹配,例如, pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应模式. 示例1: 输入: pattern = "abba", str = "dog cat cat dog" 输出: true 示例 2: 输入:pattern = "abba", str = "dog cat cat fish&

【leetcode 简单】 第九十六题 最长回文串

给定一个包含大写字母和小写字母的字符串,找到通过这些字母构造成的最长的回文串. 在构造过程中,请注意区分大小写.比如 "Aa" 不能当做一个回文字符串. 注意: 假设字符串的长度不会超过 1010. 示例 1: 输入: "abccccdd" 输出: 7 解释: 我们可以构造的最长的回文串是"dccaccd", 它的长度是 7. class Solution(object): def longestPalindrome(self, s): &quo

【leetcode 简单】 第九十一题 找不同

给定两个字符串 s 和 t,它们只包含小写字母. 字符串 t 由字符串 s 随机重排,然后在随机位置添加一个字母. 请找出在 t 中被添加的字母. 示例: 输入: s = "abcd" t = "abcde" 输出: e 解释: 'e' 是那个被添加的字母. class Solution(object): def findTheDifference(self, s, t): """ :type s: str :type t: str :

leetcode刷题--两数之和(简单)

一.序言 第一次刷leetcode的题,之前从来没有刷题然后去面试的概念,直到临近秋招,或许是秋招结束的时候才有这个意识,原来面试是需要刷题的,面试问的问题都是千篇一律的,只要刷够了题就差不多了,当然你的基础也要扎实,毕竟在技术面的时候很容易露馅的. 所以奉劝各位还未毕业,在大三或大二的师弟师妹早点刷题,心里也有底气进入求职大军,毕竟大四开始刷题的话时间上有些太紧了,推荐刷题的话就是牛客和leetcode. 回归正题,这次记录的是leetcode刷的第一题--两数之和. 二.审题 审题真的很重要