LeetCode初级算法代码

最新推荐文章于 2024-07-15 12:10:21 发布
最新推荐文章于 2024-07-15 12:10:21 发布
阅读量393 收藏
点赞数
文章标签： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/windfly17/article/details/111137106
版权

简单算法

1. 数组

1. 双指针

​ 删除排序数组中的重复项：双指针一快一慢，慢指针为最终输出数组

def removeDuplicates(self, nums: List[int]) -> int:
        l = len(nums)
        i, j = 0, 1
        if l < 2:return l;
        for a in range(l-1):
            if nums[i] != nums[j]:
                i += 1
                nums[i] = nums[j]
            j +=1
        nums = nums[0:i+1]
        return len(nums);

2. 贪心算法

​ 问题求解时，总是做出目前最优的方案

def maxProfit(self, prices: List[int]) -> int:
        income = 0
        for i in range(1,len(prices)):
            income += max(0, prices[i]-prices[i-1])
        return income

3. 旋转数组

1. 暴力法
		每次移动一个元素

def rotate(self, nums: List[int], k: int) -> None:
    temp ,previous = 0, 0
    for i in range(k):
        previous = nums[len(nums) - 1]
        for j in range(len(nums)):
            temp = nums[j]
            nums[j] = previous
            previous = temp
    return nums

​ 时间复杂度：O(n*k) 空间复杂度O(1)

2. 反转
		当我们旋转数组 k 次， *k%n* 个尾部元素会被移动到头部，剩下的元素会被向后移动

def rotate(self, nums: List[int], k: int) -> None:
    n = len(nums)
    k %= n
    nums[:] = nums[::-1]		#反转整个数组
    nums[:k] = nums[:k][::-1]	#反转前k个元素
    nums[k:] = nums[k:][::-1]	#反转剩下的元素

​ 时间复杂度：O(n) 空间复杂度O(1)

3. 环状替代

​ 数组内元素的移动可以形成一个或多个闭环，只需一次遍历即可

	def rotate(self, nums: List[int], k: int) -> None:
	    count,index,temp = 0,0,nums[0]
	    done_index = [0]
	    while count < len(nums):
	        count,target = count+1, (index + k) % len(nums)
	        temp,nums[target] = nums[target],temp
	        if target not in done_index:
	            index = target
	        elif target + 1 < len(nums):
	            index,temp = target + 1,nums[target + 1]
	        done_index.append(index)

​ 时间复杂度：O(n) 空间复杂度O(1)

4. 存在重复元素

1. 朴素线性查找

​ 依次逐个检查列表中的元素，直到找到满足的元素

def containsDuplicate(self, nums: List[int]) -> bool:
    for i in range(len(nums)):
        for j in range(i):
            if nums[j] == nums[i]:
                return True
    return False

​ 时间复杂度 : O(n2) 空间复杂度 : O(1)

2. 排序

​ 将数组排列后，扫描是否有连续的重复元素

def containsDuplicate(self, nums: List[int]) -> bool:
    nums.sort()
    for i in range(len(nums)-1):
        if nums[i] == nums[i + 1]:
            return True
    return False

​ 时间复杂度 : O(n log n) 空间复杂度：O(1)

3. 哈希表

​ 利用支持快速搜索和插入操作的动态数据结构。

def containsDuplicate(self, nums: List[int]) -> bool:
	return len(nums) != len(set(nums))		#set()可以自动去重，自动排序

​ 时间复杂度：O(n) 空间复杂度：O(n)

5. 只出现一次的数字(重复两次)

1. 位运算

​ 数组中的全部元素的异或运算结果即为数组中只出现一次的数字 eg：6 ^4 = 4^6

def singleNumber(self, nums: List[int]) -> int:
    return reduce(lambda x, y: x ^ y, nums)

​ 时间复杂度：O(n) 空间复杂度：O(1)

2.排序
def singleNumber(nums):
    if len(nums)==1:   #如果数组长度为1，则直接返回即可
        return nums[0]   
    nums.sort()     #对数组进行排序，使其相同元素靠在一起
    for i in range(1,len(nums),2):   #循环数组，验证前后是否相同，由于原始出现两次，因此可跳跃判断
        if nums[i-1] != nums[i]:
            return nums[i-1]
        if (i+2) == len(nums):   #判断单一元素在排序后数组的最后面
            return nums[-1]
3.删除元素

​ 依次删除列表的元素

def singleNumber(nums):
    while True:
        d = nums[0]
        nums.remove(d)
        try:
            nums.remove(d)
        except:
            return d

6. 两个数组的交集

1.哈希表

​ 用哈希表存储每个数字出现的次数

def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
    if len(nums1) > len(nums2):
        return self.intersect(nums2, nums1)
    m = collections.Counter()
    for num in nums1:
        m[num] += 1
    intersection = list()
    for num in nums2:
        if (count := m.get(num, 0)) > 0:
            intersection.append(num)
            m[num] -= 1
            if m[num] == 0:
                m.pop(num)
    return intersection

​ 时间复杂度：O(m+n) 空间复杂度：O(min(m,n))

2. 双指针

​ 先对两个数组进行排序，然后使用两个指针遍历两个数组。

def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
    nums1.sort()
    nums2.sort()

    length1, length2 = len(nums1), len(nums2)
    intersection = list()
    index1 = index2 = 0
    while index1 < length1 and index2 < length2:
        if nums1[index1] < nums2[index2]:
            index1 += 1
        elif nums1[index1] > nums2[index2]:
            index2 += 1
        else:
            intersection.append(nums1[index1])
            index1 += 1
            index2 += 1
	return intersection

​ 时间复杂度：O(m log m+n log n) 空间复杂度：O(min(m,n))

7. 数组最后一位加一，每个元素为 0-9

1.数组合成数字
 def plusOne(digits) :
        nums_s = ''.join([str(x) for x in digits])   #先将其数组中的值转换为字符串，然后进行拼接 
        nums = str(int(nums_s) + 1)  
        r = [int(x) for x in nums]   
        return [0]*(len(digits)-len(r)) + r   #数组前面可能存在多个0，防止这种情况出现
2.从数组尾部遍历
def plusOne(self, digits: List[int]) -> List[int]:
    for i in range(len(digits),0,-1):    #循环数组，从最后一位开始计算
        if digits[i-1] == 9:    #如果为9，则相加为十，需要向前进一位
            digits[i-1] = 0
        	if i == 1 :       #如果满十进位到数组第一个，则数组需要增加一位
            	digits = [1] + digits
        else:
            digits[i-1] += 1   #不等于9就终止循环结束
            break
     return digits

8. 移动数组中零

def moveZeroes(self, nums: List[int]) -> None:
    i = 0
    for a in range(len(nums)):
        if nums[i] == 0:
            del nums[i]
            nums.append(0)
        else:
            i += 1
     return nums

9.两数之和

哈希表

​ 创建一个哈希表，对于每一个x，我们首先查询哈希表中是否存在target - x，然后将x插入到哈希表中

def twoSum(self, nums: List[int], target: int) -> List[int]:
    hashtable = dict()
    for i, num in enumerate(nums):
        if target - num in hashtable:
            return [hashtable[target - num], i]
        hashtable[nums[i]] = i
    return []

10. 有效的数独

def isValidSudoku(self, board: List[List[str]]) -> bool:
row = [{} for _ in range(9)]
col = [{} for _ in range(9)]
grid = [[{} for _ in range(3)] for _ in range(3)]
for i in range(9):
    for j in range(9):
        if board[i][j] != '.':
            tmp = int(board[i][j])
            row[i][tmp] = row[i].get(tmp, 0) + 1		#get("位置", “不存在时返回值”)
            col[j][tmp] = col[j].get(tmp, 0) + 1
            grid[i//3][j//3][tmp] = grid[i//3][j//3].get(tmp, 0) + 1
            if row[i].get(tmp) > 1 or col[j].get(tmp) > 1 or grid[i//3][j//3].get(tmp) > 1:
                return False
return True

11.旋转图像

image.png 
def rotate(self, matrix: List[List[int]]) -> None:
n = len(matrix[0])        
for i in range(n // 2 + n % 2):
    for j in range(n // 2):
        tmp = matrix[n - 1 - j][i]							    #左上角
        matrix[n - 1 - j][i] = matrix[n - 1 - i][n - j - 1]		  #右上角
        matrix[n - 1 - i][n - j - 1] = matrix[j][n - 1 -i]		  #右下角
        matrix[j][n - 1 - i] = matrix[i][j]					     #左下角
        matrix[i][j] = tmp									   #左上角

2.字符串

1. 反转字符串

def reverseString(self, s: List[str]) -> None:
    for i in range(len(s),len(s)//2,-1):
        s[i-1],s[len(s)-i] = s[len(s)-i],s[i-1]

def reverseString(self, s: List[str]) -> None:
    s.reverse()

def reverseString(self, s: List[str]) -> None:
    s = s[::-1]

2. 整数反转

​ 将整数转换为字符串

def reverse(self, x: int) -> int:
        s = str(x)
        if s[0] == '-':
            x = int('-' + s[1:][::-1])
        else:
            x = int(s[::-1])
        if (-2147483648 <= x <= 2147483647):
            return x
        else:
            return 0

3. 字符串中的第一个唯一字符

def firstUniqChar(self, s: str) -> int:
    count = collections.Counter(s)		#统计s中元素出现频率
    for idx, ch in enumerate(s):		#idx 为s中内容的序号，ch为s中内容
        if count[ch] == 1:
            return idx
    return -1

4. 有效的字母异位词

1.排序法

将字符串保存到容器，进行sort排序，然后依次对比

def isAnagram(self, s: str, t: str) -> bool:
    if len(s) != len (t):
        return False
    a = 0
    s_l = list(s)
    t_l = list(t)
    s_l.sort()
    t_l.sort()
    s_0 = "".join(s_l)
    t_0 = "".join(t_l)
    for i in range(len(s)):
        if s_0[i] == t_0[i]:
            a += 1
    if a == len(s):
    	return True
    else:
    	return False
2.哈希表

利用collections.Counter函数

def isAnagram(self, s: str, t: str) -> bool:
    return collections.Counter(s) == collections.Counter(t)

5. 验证回文串

1.筛选判断

先筛选出所有字母与数字，并将字母全部小写，然后判断

def isPalindrome(self, s: str) -> bool:
    sgood = "".join(ch.lower() for ch in s if ch.isalnum())	#lower()将字母小写，ch.isalnum()判断是否为字母与数字
    return sgood == sgood[::-1]
3. 在原字符串上直接判断

利用双指针

def isPalindrome(self, s: str) -> bool:
    n = len(s)
    left, right = 0, n - 1
        
    while left < right:
        while left < right and not s[left].isalnum():
            left += 1
        while left < right and not s[right].isalnum():
            right -= 1
        if left < right:
            if s[left].lower() != s[right].lower():
                return False
            left, right = left + 1, right - 1
     return True

4. 字符串转换整数 (atoi)

1.正常遍历
class Solution:
    def myAtoi(self, s: str) -> int:
        i=0
        n=len(s)
        while i<n and s[i]==' ':
            i=i+1
        if n==0 or i==n:
            return 0
        flag=1
        if s[i]=='-':
            flag=-1
        if s[i]=='+' or s[i]=='-':
            i=i+1
        INT_MAX=2**31-1
        INT_MIN=-2**31
        ans=0
        while i<n and '0'<=s[i]<='9':
            ans=ans*10+int(s[i])-int('0')
            i+=1
            if(ans-1>INT_MAX):
                break

        ans=ans*flag
        if ans>INT_MAX:
            return INT_MAX
        return INT_MIN if ans<INT_MIN else ans
2.有限状态机
' '+/-numberother
startstartsignedin_numberend
signedendendin_numberend
in_numberendendin_numberend
endendendendend
INT_MAX = 2 ** 31 - 1
INT_MIN = -2 ** 31

class Automaton:
    def __init__(self):
        self.state = 'start'
        self.sign = 1
        self.ans = 0
        self.table = {
            'start': ['start', 'signed', 'in_number', 'end'],
            'signed': ['end', 'end', 'in_number', 'end'],
            'in_number': ['end', 'end', 'in_number', 'end'],
            'end': ['end', 'end', 'end', 'end'],
        }
        
    def get_col(self, c):
        if c.isspace():
            return 0
        if c == '+' or c == '-':
            return 1
        if c.isdigit():
            return 2
        return 3

    def get(self, c):
        self.state = self.table[self.state][self.get_col(c)]
        if self.state == 'in_number':
            self.ans = self.ans * 10 + int(c)
            self.ans = min(self.ans, INT_MAX) if self.sign == 1 else min(self.ans, -INT_MIN)
        elif self.state == 'signed':
            self.sign = 1 if c == '+' else -1

class Solution:
    def myAtoi(self, str: str) -> int:
        automaton = Automaton()
        for c in str:
            automaton.get(c)
        return automaton.sign * automaton.ans
4.正则表达
def myAtoi(self, str: str) -> int:
        INT_MAX = 2147483647    
        INT_MIN = -2147483648
        str = str.lstrip()      #清除左边多余的空格
        num_re = re.compile(r'^[\+\-]?\d+')   #设置正则规则
        num = num_re.findall(str)   #查找匹配的内容
        num = int(*num) #由于返回的是个列表，解包并且转换成整数
        return max(min(num,INT_MAX),INT_MIN)    #返回值
  
元字符
  
匹配内容
. 匹配除换行符以外的任意字符
\w匹配字母或数字或下划线
\s匹配任意的空白符
\d匹配数字
\n匹配一个换行符
\t匹配一个制表符
\b匹配一个单词的结尾
^匹配字符串的开始
$匹配字符串的结尾
\W 
匹配非字母或数字或下划线
\D 
匹配非数字
\S 
匹配非空白符
a|b 
匹配字符a或字符b
() 
匹配括号内的表达式，也表示一个组
[...] 
匹配字符组中的字符
[^...] 
匹配除了字符组中字符的所有字符
量词
 
用法说明
*重复零次或更多次
+重复一次或更多次
?重复零次或一次
{n}重复n次
{n,}重复n次或更多次
{n,m}重复n到m次

5. 实现 strStr()

1.子串逐一比较 - 线性时间复杂度

沿着字符换逐步移动滑动窗口，将窗口内的子串与 needle 字符串比较。

def strStr(self, haystack: str, needle: str) -> int:
    L, n = len(needle), len(haystack)
    for start in range(n - L + 1):
        if haystack[start: start + L] == needle:
            return start
    return -1
2.双指针 - 线性时间复杂度
def strStr(self, haystack: str, needle: str) -> int:
        L, n = len(needle), len(haystack)
        if L == 0:
            return 0
        pn = 0
        while pn < n - L + 1:
            while pn < n - L + 1 and haystack[pn] != needle[0]:	# 与第一个字母不匹配
                pn += 1
            curr_len = pL = 0
            while pL < L and pn < n and haystack[pn] == needle[pL]:	# 与第一个字母匹配
                pn += 1
                pL += 1
                curr_len += 1
            
            # if the whole needle string is found,
            # return its start position
            if curr_len == L:
                return pn - L
            
            # otherwise, backtrack
            pn = pn - curr_len + 1	# 出现不匹配字母
        return -1
3。Rabin Karp - 常数复杂度

先生成窗口内子串的哈希码，然后再跟 needle 字符串的哈希码做比较。

def strStr(self, haystack: str, needle: str) -> int:
    L, n = len(needle), len(haystack)
    if L > n:
        return -1

    # base value for the rolling hash function
    a = 26
    # modulus value for the rolling hash function to avoid overflow
    modulus = 2**31

    # lambda-function to convert character to integer
    h_to_int = lambda i : ord(haystack[i]) - ord('a')
    needle_to_int = lambda i : ord(needle[i]) - ord('a')

    # compute the hash of strings haystack[:L], needle[:L]
    h = ref_h = 0
    for i in range(L):
        h = (h * a + h_to_int(i)) % modulus
        ref_h = (ref_h * a + needle_to_int(i)) % modulus
    if h == ref_h:
        return 0
              
    # const value to be used often : a**L % modulus
    aL = pow(a, L, modulus) 
    for start in range(1, n - L + 1):
        # compute rolling hash in O(1) time
        h = (h * a - h_to_int(start - 1) * aL + h_to_int(start + L - 1)) % modulus
        if h == ref_h:
            return start

h 0 = c 0 a L − 1 + c 1 a L − 2 + . . . + c L − 1 a 2 + c L a 1 h_0=c_0a^{L-1}+c_1a^{L-2}+...+c_{L-1}a^2+c_La^1 h0​=c0​aL−1+c1​aL−2+...+cL−1​a2+cL​a1

h 1 = h 0 a − c 0 a L + c L + 1 h_1=h_0a-c_0a^L+c_{L+1} h1​=h0​a−c0​aL+cL+1​

6. 外观数列

1. 双指针实现
def countAndSay(self, n: int) -> str:
    pre = ''
    cur = '1'
    # 从第 2 项开始
    for _ in range(1, n):
        # 这里注意要将 cur 赋值给 pre
        # 因为当前项，就是下一项的前一项。有点绕，尝试理解下
        pre = cur
        # 这里 cur 初始化为空，重新拼接
        cur = ''
        # 定义双指针 start，end
        start = 0
        end = 0
        # 开始遍历前一项，开始描述
        while end < len(pre):
            # 统计重复元素的次数，出现不同元素时，停止
            # 记录出现的次数，
            while end < len(pre) and pre[start] == pre[end]:
                end += 1
            # 元素出现次数与元素进行拼接
            cur += str(end-start) + pre[start]
            # 这里更新 start，开始记录下一个元素
            start = end
    return cur
2.正则表达式(实现)：提取元素
def countAndSay(self, n: int) -> str:
    if n == 1:
    	return "1"
    s = self.countAndSay(n-1)
    # 字符串 (\d)\1* 可以用来匹配结果。这里用来提取连在一块的元素， 如 '111221'，提取出的元素是 res = ['111', '22', '1']。
    # (\d)\1*解释：
    # \1 是为了引用前面的 \d，表明 \1 是与 \d 匹配到相同的数字。
    # 只有 \d 添加了（），才能被引用，在正则里面称之为捕获组。
    # * 表示重复匹配前面字符0次或多次。所以可以匹配的到像 1 、111、11 这样连在一起并相同的数字。
    pattern = re.compile(r'(\d)\1*')
    res = [_.group() for _ in pattern.finditer(s)]
    return ''.join(str(len(c)) + c[0] for c in res)
3.正则表达式(实现)：元素替换
def countAndSay(self, n: int) -> str:
    res = "1"
    pattern= re.compile(r'(\d)\1*')
    for _ in range(n-1):
        res = pattern.sub(lambda x: str(len(x.group())) + x.group(1), res) # 核心代码，实现元素的替换
    return res

7. 最长公共前缀

1. 纵向扫描
def longestCommonPrefix(self, strs: List[str]) -> str:
    if not strs:
        return ""
    length, count = len(strs[0]), len(strs)
    for i in range(length):
        c = strs[0][i]
        if any(i == len(strs[j]) or strs[j][i] != c for j in range(1, count)):
            return strs[0][:i]
    return strs[0]
2. 纵向扫描
def longestCommonPrefix(self, s: List[str]) -> str:
        if not s:
            return ""
        res = s[0]
        i = 1
        while i < len(s):
            while s[i].find(res) != 0:
                res = res[0:len(res)-1]
            i += 1
        return res
3. python特性
def longestCommonPrefix(self, strs):
    res = ""
    for tmp in zip(*strs):
        tmp_set = set(tmp)
        if len(tmp_set) == 1:
            res += tmp[0]
        else:
            break
    return res

3. 链表

1. 删除链表中的节点

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

def deleteNode(self, node):
    """
    :type node: ListNode
    :rtype: void Do not return anything, modify node in-place instead.
    """
    node.val = node.next.val
    node.next = node.next.next

2. 删除链表的倒数第N个节点

1. 循环迭代
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
    dummy = ListNode(0)
    dummy.next = head

    #step1: 获取链表长度
    cur, length = head, 0 
    while cur:
        length += 1
        cur = cur.next 

    #step2: 找到倒数第N个节点的前面一个节点
    cur = dummy
    for _ in range(length - n):
        cur = cur.next
    
    #step3: 删除节点，并重新连接
    cur.next = cur.next.next
    return dummy.next
2. 双指针
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
    dummy = ListNode(0)
    dummy.next = head
    
    slow, fast = dummy, dummy
    for _ in range(n):
        fast = fast.next
       
    while fast and fast.next:
        slow, fast = slow.next, fast.next
        
    slow.next = slow.next.next
    
    return dummy.next
3. 递归迭代
![递归](D:\Desktop\啊这\递归.gif)def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
    if not head: # 判断是否为最后一个节点
        self.count = 0
        return head  
    head.next = self.removeNthFromEnd(head.next, n) # 递归调用
    self.count += 1 # 回溯时进行节点计数
    return head.next if self.count == n else head

3. 反转链表

1. 双指针
def reverseList(self, head: ListNode) -> ListNode:
    pre = None
    cur = head
    while cur:
        tmp = cur.next	# 暂存
        cur.next = pre	# 倒序
        pre = cur		# 进位
        cur = tmp
    return pre
2. 递归解法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7fuhOVnK-1608036976052)(https://i.loli.net/2020/12/15/H4U9nb5gPV7hfYS.gif)]

def reverseList(self, head: ListNode) -> ListNode:
    if(head==None or head.next==None):
		return head
		# 这里的cur就是最后一个节点
		cur = self.reverseList(head.next)
		# 这里请配合动画演示理解
		# 如果链表是 1->2->3->4->5，那么此时的cur就是5
		# 而head是4，head的下一个是5，下下一个是空
		# 所以head.next.next 就是5->4
		head.next.next = head
		# 防止链表循环，需要将head.next设置为空
		head.next = None
		# 每层递归函数都返回cur，也就是最后一个节点
		return cur

4. 合并两个有序链表

1. 迭代
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
    res = ListNode(-1)
    cur = res
    while l1 and l2:
        if l1.val <= l2.val :
            cur.next = l1
            l1 = l1.next
        else:
            cur.next = l2
            l2 = l2.next
            cur = cur.next
    cur.next = l1 if l1 is not None else l2
    return res.next
2.迭代
def mergeTwoLists(self, l1, l2):
    if l1 is None:
        return l2
    elif l2 is None:
        return l1
    elif l1.val < l2.val:
        l1.next = self.mergeTwoLists(l1.next, l2)
        return l1
    else:
        l2.next = self.mergeTwoLists(l1, l2.next)
        return l2
windfly17
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode - 103道入门基础题
seaalan的博客
11-22 1682
一、leetcode - 字符串 二、leetcode - 二进制、数学类 三、leetcode - 数组 四、leetcode - 二分查找 五、leetcode - 快慢指针 六、leetcode - 滑动窗口 七、leetcode - 矩阵 八、leetcode - 栈和队列 九、leetcode - 链表 十、leetcode - 二叉树 十一、leetcode - 并查集 十二、leetcode - 回溯 十三、leetcode - 动态规划 十四、leetcode - 贪心 一、leetcode
LeetCode初级算法
qiao_lili的博客
10-31 340
目录 1.数组 2.字符串 3.链表 4.树 5.排序和搜索 6.动态规划 7.设计问题 8.数学 9.其他 1.数组 1.1 给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。 不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。 class Solution { public: ...
leetcode算法与代码总结
一只在cv道路上爬行的小乌龟~
07-13 3294
leetcode代码总结1.动态规划问题动态规划思想介绍1. 1.动态规划问题 动态规划思想介绍 1.
【leetcode刷题总结】——代码随想录（链表总结）
lingxw的博客
05-18 3004
什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
LeetCode初级算法笔记
weixin_55139299的博客
10-04 346
LeetCode初级算法笔记
Leetcode——初级算法（数组篇）
Clear_tj的博客
05-24 347
Leetcode——初级算法（数组篇）
LeetCode初级算法篇
qq_43965508的博客
10-14 146
前言 为秋招做的准备：从7月份中旬开始刷算法，拢共刷了100多道（我知道很少！书写出来以便激励自己！！！），此篇为初级算法； 注意！！！ ！！根据CSDN以及博客园大佬的题解增加自己的见解，不做商用，只为自己学习用！！若路过大佬发现您的题解帮助我解题，但是不允许转载（应该也不算，因为这是鄙人自己拙劣的解析，比不上大佬的题解），请大佬联系我，我马上删除！！！ 此处为初级算法入口 数组 删除排序数组中的重复项 class Solution { public int removeDuplicates(in
leetcode初级算法.zip
10-23
本压缩包“leetcode初级算法.zip”中包含了作者精心编写的C++代码，每个文件对应一个LeetCode的初级算法题目，文件名即为题目名称。代码中包含了详细的注释，不仅展示了解题思路，还融入了作者的个人感悟和总结，这...
LeetCode初级算法笔记整理
11-17
初级算法笔记整理是对LeetCode上入门级别的算法问题的总结和学习心得，这些笔记通常包括问题的解析、解题思路、代码实现以及可能的优化。这份笔记以HTML格式导出，方便在不同的设备和环境中阅读。 在Java编程语言中...
LeetCode初级算法-数组（手写）
10-09
LeetCode初级算法-数组内容，共10个题，代码手写，可能不太清楚
leetcode答案-LeetCode:leetcode中初级算法的答案
06-30
这个压缩包文件"LeetCode-master"很可能包含了一位开发者编写的针对LeetCode中初级算法题目的解决方案。 在LeetCode上，题目通常分为几个难度等级：Easy、Medium和Hard。"中级算法"可能指的是Medium级别的题目，...
LeetCode:算法和东西
03-13
"leetcode"标签直接与LeetCode平台相关，该平台上的问题覆盖了初级到高级的各种算法挑战，适合各种水平的开发者进行自我提升。通过解决LeetCode上的问题，开发者可以提高自己的编程技巧，同时也能为面试做好准备，...
Leetcode 常用代码
qq_40783389的博客
10-13 575
Leetcode 常用代码
Leetcode各种题型题目+思路+代码（共176道题及答案）
热门推荐
muli522的博客
05-16 4万+
文章目录 第一章：Leetcode 每日很多题 1、Leetcode-1047 删除字符串中的所有相邻重复项 2、剑指 Offer 53 - I. 在排序数组中查找数字 I 3、Leetcode704:二分查找 4、 Leetcode 227：基本计算器II 5、leetcode 224：基本计算器(带括号的计算) 6、Leetcode 15：三数之和：排序+双指针 7、剑指 offer 38.字符串的排列 8、Leetcode409：最长回文串 9、Leetcode 331：验证二叉树的前序序列化 10、
LeetCode代码刷题（17~24）
sulia1234567890的博客
05-12 453
目录 17.电话号码的字母组合 17.电话号码的字母组合 题目： 给定一个仅包含数字2-9的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例 1： 输入：digits = "23" 输出：["ad","ae","af","bd","be","bf","cd","ce","cf"] 示例 2： 输入：digits = "" 输出：[] 示例 3： 输入：digits = "2" 输...
leetcode-代码测试模板
qq_34179431的博客
06-23 833
代码提交前的测试模板 #include <iostream> #include <utility> #include <string> #include <cstring> #include <vector> #include <map> #include <set> #include <stack> #include <queue> #include <unordered_map> #i
leetcode:代码基础
qq_43808588的博客
09-14 703
单词书写 Arrays.sort(nums); StringBuffer deleteCharAt for (int i = 0, j = n - 1, pos = n - 1; i <= j;)，start += 2 * k更新步数 int ans = Integer.MAX_VALUE; map.put(tree[i], map.getOrDefault(tree[i], 0) + 1); map.remove，。map.get(),map. Map<Character, I.
Array6: 350. 两个数组的交集 II
人工智能曾小健
05-24 151
class Solution: def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]: if len(nums1) > len(nums2): return self.intersect(nums2, nums1) m = collections.Counter() for num in nums1: .
LEETCODE100热题双指针
最新发布
m0_74484354的博客
07-15 109
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
LeetCode 初级算法案例 Java 实现（数组篇）
"LeeCode初级算法案例+java代码（数组篇）" 本文总结了LeeCode初级算法案例中的数组篇，涵盖了9个不同的算法题目，包括删除排序数组的重复项、买卖股票的最佳时机II、旋转数组、存在重复元素、只出现一次的数字、两...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值