LeetCode 刷题记录

最新推荐文章于 2022-08-14 22:24:17 发布

JasonLee315

最新推荐文章于 2022-08-14 22:24:17 发布

阅读量211

点赞数

分类专栏：数据结构与算法

原文链接：https://leetcode.com/

版权

数据结构与算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

记录的原则:

遇到确认以后都会的只记录下题号（没有意义再看一次的）
不同题组中重复的用斜体标注出来
第一遍就不会的记录题号加mark
会的，但是不是很顺利，思路不是很连贯的 or 有别人写的很好的（贴code）
加一些 TODO 今后要做的事情。

顺序是从 Top interview 150 -> top liked 100:
Top acceptance -> lowest acceptance.
剑指offer

TOP interview

344 Reverse String (in place change, 注意不要 for 循环到最后换两次等于没换 )
104 Maximum Depth of Binary Tree （最简单的递归，注意用 buffer 存左右子树的数值）
136 Single Number （异或）
412 Fizz Buzz

class Solution:
    def fizzBuzz(self, n: int) -> List[str]:
        return ['Fizz' * (not i % 3) + 'Buzz' * (not i % 5) or str(i) for i in range(1, n + 1)]

94 Binary Tree Inorder Traversal 用中序遍历就是常法，这里貌似有点分治的思想。。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    int *res = NULL;
    if (!root) {*returnSize = 0; return NULL;}
    int *leftarr = NULL, *rightarr = NULL, leftsize = 0, rightsize = 0;
    if (root->left)
        leftarr = inorderTraversal(root->left, &leftsize);
    if (root->right)
        rightarr = inorderTraversal(root->right, &rightsize);
    *returnSize = leftsize + 1 +rightsize;
    res = (int *)(malloc(sizeof(int)* (*returnSize)));
    int i,j;
    for (i = 0; i < leftsize; i++)
        res[i] = leftarr[i];
    res[i++] = root->val;
    for (j = 0; j < rightsize; j++)
        res[i + j] = rightarr[j];
    free(leftarr);
    free(rightarr);
    return res;
}

46 Permutations for 循环 dfs
22 Generate Parentheses left,right 记录左右括号 dfs
206 Reverse Linked List 循环很容易递归两个参数 (prev, node_now)
347 Top K Frequent Elements

t = sorted(s.items(), key = lambda x: x[1], reverse = True)

238 Product of Array Except Self
283 Move Zeroes
237 Delete Node in a Linked List
78 Subsets

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        res = []
        self.dfs(nums,[],res,0)
        return res
    def dfs(self, nums, path, res, index):
        res.append(path)
        for i in range(index, len(nums)):
            self.dfs(nums, path + [nums[i]], res, i + 1)

169 Majority Element 投票法。。
242 Valid Anagram set or hash table
13 Roman to Integer 算法其实很简单。。。

class Solution:
    def romanToInt(self, s: str) -> int:
        roman = {'I' : 1, 'V' : 5, 'X' : 10, 'L' : 50, 'C' : 100, 'D': 500, 'M' : 1000}
        res = 0
        for i in range(len(s) - 1):
            if roman[s[i]] < roman[s[i + 1]]:
                res -= roman[s[i]]
            else:
                res += roman[s[i]]
        return res + roman[s[-1]]

217 Contains Duplicate TODO: C hash table
122 Best Time to Buy and Sell Stock II

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

230 Kth Smallest Element in a BST 中序遍历
171 Excel Sheet Column Number
108 Convert Sorted Array to Binary Search Tree
c 的 helper function 的思想还是可以的两个pointer

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


struct TreeNode* convert(int* nums,int start,int end)
{
     if(start > end)
          return NULL;
     else{
         int mid = (start+end+1)/2;
         struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
         node->val = nums[mid];
         node->left = convert(nums,start,mid-1);
         node->right = convert(nums,mid+1,end);
         return node;
     }
}


struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
        return convert(nums,0,numsSize-1);
}

454 4Sum II (A+B) (C+D) O2*n的复杂度，用哈希表存结果
371 Sum of Two Integers 所有的东西都要强制转化一波成 unsigned int
384 Shuffle an Array

class Solution:
    def __init__(self, nums):
        self.array = nums
        self.original = list(nums)

    def reset(self):
        self.array = self.original
        self.original = list(self.original)
        return self.array

    def shuffle(self):
        for i in range(len(self.array)):
            swap_idx = random.randrange(i, len(self.array))
            self.array[i], self.array[swap_idx] = self.array[swap_idx], self.array[i]
        return self.array

287 Find the Duplicate Number binary search

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        l = 1
        r = len(nums) - 1
        while l < r:
            mid = (l + r) // 2
            counter = 0
            for n in nums:
                if n <= mid:
                    counter += 1
            if counter > mid:
                r = mid
            else:
                l = mid + 1
        return l

387 First Unique Character in a String 用 hash table
378 Kth Smallest Element in a Sorted Matrix TODO (HEAP) Hint binary search 选对search space。
328 Odd Even Linked List
48 Rotate Image

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

a = [[1,2,3],[2,3,4]]
a[::-1] -> [[2,3,4],[1,2,3]]

102 Binary Tree Level Order Traversal TODO (how to use C programming language)
215 Kth Largest Element in an Array heap
268 Missing Number
341 Flatten Nested List Iterator
62 Unique Paths
350 Intersection of Two Arrays II
21 Merge Two Sorted Lists
121 Best Time to Buy and Sell Stock
118 Pascal’s Triangle
289 Game of Life
11 Container With Most Water

class Solution:
    def maxArea(self, height: List[int]) -> int:
        l = 0
        r = len(height) - 1
        maxwater = 0
        while l < r:
            maxwater = max(maxwater, (r - l) * min(height[l],height[r]))
            if height[l] < height[r]:
                l += 1
            else:
                r -= 1
        return maxwater

此题可以用反正法 height: list[n]
假设初始位置是 l = 0, r = n - 1
最优值是 i, j 其中 l <= i < j <= r 对吧
假设左边先到达 i ，此时左边不可能再向右边移动了。
因为如果左边右移只可能是右边的值大于左边，此时假设的最优值不成立！i, r 一定是优于 i,j才能导致 i 右移。与假设违背。

202 Happy Number

class Solution:
    def isHappy(self, n: int) -> bool:
        mem = set()
        while n != 1:
            n = sum(int(i) ** 2 for i in str(n))
            if n in mem:
                return False
            else:
                mem.add(n)
        return True

36 Valid Sudoku

class Solution:
    def isValidSudoku(self, board):
        """
        :type board: List[List[str]]
        :rtype: bool
        """
        return self.is_block_valid(board) and self.is_col_valid(board) and \
        self.is_row_valid(board)
    def is_unit_valid(self,unit):
        unit2 = [item for item in unit if item != '.']
        return len(unit2) == len(set(unit2))
    def is_row_valid(self,board):
        for row in board:
            if not self.is_unit_valid(row):
                return False
        return True
    def is_col_valid(self,board):
        for col in zip(*board):
            if not self.is_unit_valid(col):
                return False
        return True
    def is_block_valid(self,board):
        for i in (0,3,6):
            for j in (0,3,6):
                square = [board[x][y] for x in range(i,i+3) for y in range(j,j+3)]
                if not self.is_unit_valid(square):
                    return False
        return True

36 Valid Sudoku
42 Trapping Rain Water
53 Maximum Subarray
1 Two Sum
101 Symmetric Tree

Top liked

617 Merge Two Binary Trees
338 Counting Bits
104 Maximum Depth of Binary Tree （最简单的递归，注意用 buffer 存左右子树的数值）
136 Single Number （异或）
406 Queue Reconstruction by Height

class Solution:
    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
        inorder_sequence = sorted(people, key = lambda x: (-x[0],x[1]))
        inorderLine = []
        for person in inorder_sequence:
            inorderLine.insert(person[1], person)
        return inorderLine

739 Daily Temperatures
226 Invert Binary Tree
94 Binary Tree Inorder Traversal

int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    int *res = NULL;
    if (!root) {*returnSize = 0; return NULL;}
    int *leftarr = NULL, *rightarr = NULL, leftsize = 0, rightsize = 0;
    if (root->left)
        leftarr = inorderTraversal(root->left, &leftsize);
    if (root->right)
        rightarr = inorderTraversal(root->right, &rightsize);
    *returnSize = leftsize + 1 +rightsize;
    res = (int *)(malloc(sizeof(int)* (*returnSize)));
    int i,j;
    for (i = 0; i < leftsize; i++)
        res[i] = leftarr[i];
    res[i++] = root->val;
    for (j = 0; j < rightsize; j++)
        res[i + j] = rightarr[j];
    free(leftarr);
    free(rightarr);
    return res;
}

46 Permutations
647 Palindromic Substrings

class Solution:
    def countSubstrings(self, s):
        if not s:
            return 0

        n = len(s)
        table = [[False for x in range(n)] for y in range(n)]
        count = 0

        # Every isolated char is a palindrome
        for i in range(n):
            table[i][i] = True
            count += 1

        # Check for a window of size 2
        for i in range(n-1):
            if s[i] == s[i+1]:
                table[i][i+1] = True
                count += 1

        # Check windows of size 3 and more
        for k in range(3, n+1):
            for i in range(n-k+1):
                j = i+k-1
                if table[i+1][j-1] and s[i] == s[j]:
                    table[i][j] = True
                    count += 1

        return count

22 generate parentheses
206 Reverse Linked List

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* helper(struct ListNode* prev, struct ListNode* head) {
    if (!head)
        return prev;
    struct ListNode* tmp = head->next;
    head->next = prev;
    return helper(head, tmp);
}

struct ListNode* reverseList(struct ListNode* head){
    return helper(NULL, head);
}

304 Top K Frequent Elements

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        d = {}
        for n in nums:
            if n not in d:
                d[n] = 1
            else:
                d[n] += 1
        res = sorted(d.items(), key = lambda x :x[1], reverse = True)
        return [res[i][0] for i in range(k)]

238 Product of Array Except Self
78 Subsets

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        res = []
        self.dfs(0, nums, [], res)
        return res
    def dfs(self, index, nums, path, res):
        res.append(path)
        for i in range(index, len(nums)):
            self.dfs(i + 1, nums, path+[nums[i]], res)

283 move zeros
169 Major Element
448 Find All Numbers Disappeared in an Array
39 Combination Sum

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        res = []
        self.dfs(candidates, 0, [], target, res)
        return res
    def dfs(self, nums, index, path, target, res):
        if target < 0:
            return
        if target == 0:
            res.append(path)
            return
        for i in range(index, len(nums)):
            self.dfs(nums, i, path + [nums[i]], target - nums[i], res)

48 Rotate Image
287 Find the Duplicate Number

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        l = 1
        r = len(nums) - 1
        while l < r:
            mid = (l + r) // 2
            counter = 0
            for n in nums:
                if n <= mid:
                    counter += 1
            if counter > mid:
                r = mid
            else:
                l = mid + 1
        return l

102 Binary Tree Level Order Traversal

int maxDepthTree (struct TreeNode* root);
void InOrder (struct TreeNode* root, int** array, int* nums, int depth);
void arrayAdd (int** array, int size);

int** levelOrder(struct TreeNode* root, int** columnSizes, int* returnSize) {
  int maxDepth = *returnSize = maxDepthTree (root); 
  int** array = (int**) calloc (maxDepth, sizeof (int*));
  *columnSizes = (int *) calloc (maxDepth, sizeof (int));
  for (int i = 0; i < maxDepth; i++)
    (*columnSizes)[i] = 0;
  InOrder (root, array, *columnSizes, 0);
  return array;
}

int maxDepthTree (struct TreeNode* root)
{
  if (root == NULL)
    return 0;
  int DepthL = maxDepthTree (root->left) + 1;
  int DepthR = maxDepthTree (root->right) + 1;
  return DepthL > DepthR ? DepthL : DepthR;
}

void InOrder (struct TreeNode* root, int** array, int* nums, int depth)
{
  if (root == NULL)
    return;
  InOrder (root->left, array, nums, depth + 1);
  arrayAdd (&array[depth], nums[depth]);
  array[depth][nums[depth]++] = root->val;
  InOrder (root->right, array, nums, depth + 1);
}

void arrayAdd (int** array, int size)
{
  int* temp = *array;
  *array = (int *) calloc (size + 1, sizeof (int));
  for (int i = 0; i < size; i++)
    (*array)[i] = temp[i];
  free (temp);
}

49 Group Anagrams

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        ans = {}
        res = []
        for string in strs:
            s = ''.join(sorted(string))
            if s in ans:
                ans[s].append(string)
            else:
                ans[s] = [string]
        for i in ans.items():
            res.append(i[1])
        return res