LeetCode刷题记录

• 每天两道LeetCode题
• 第一遍:
  • 按tag刷,先刷easy 增长信心
  • 根据需要以及潮流度,先从array刷起,每种easy类型20道题之后换tag
  • 语言的话,打算用Java,最近一直在用Go,现在需要复习Java

---

Array

• 2020-02-12
  • 2 Two Sum Num
  • 26 Remove Duplicates Num
• 2020-02-13
  • 27 Remove Element
  • 35 Search Insert Position Num
• 2020-02-14
  • 53 Maximum Sub Array Num
  • 66 Plus One:
• 2020-02-15
  • 88 Merge Sorted Array
  • 118 Pascals_Triangle
• 2020-02-16
  • 119 PascalsTriangleII
  • 121 Best Time to Buy and Sell Stock
• 2020-02-17
  • 122 Best Time to Buy and Sell Stock II
  • 167 Two SumII Input array is sorted
• 2020-02-18
  • 169 Majority Element
  • 189 Rotate Array (这题考虑背了)
• 2020-02-19
  • 217 Contains Duplicate
  • 219 Contains Duplicate II
• 2020-02-20
  • 243 Shorted Word Distance
  • 268 Missing Number
• 2020-02-21
  • 283 move zeroes
  • 414 third maximum number

LinkedList

• 2020-02-22
  • 21 Merge Two Sorted Lists
  • 83 remove duplicates from sorted list
• 2020-02-23
  • 141 Linked List Cycle
  • 160 Intersection of Two Linked Lists
• 2020-02-24
  • 203 Remove Linked List Elements
  • 206 Reverse Linked List

    递归实现与循环实现是一模一样的思路,就是先保存下一个节点,
    然后当前节点重新指向前一个节点
    然后先移动前一个节点到当前节点,
    因为对next而言,它的prev就是cur节点,
    然后cur节点移动到下一个节点作为新的cur节点
    

• 2020-02-25

  • 234 palindrome-linked-list

    卡在限制条件上,O(n)时间复杂度,O(1)空间复杂度
    最后,似乎只能快慢指针加上反转实现

    public boolean isPalindrome(ListNode head)
        {
            if (null == head) return true;
            ListNode fast = head.next;
            ListNode slow = head;
            while (fast != null && fast.next != null)
            {
                fast = fast.next.next;
                slow = slow.next;
            }
            if (null != slow)
            {
                slow = slow.next;
            }
            slow = reverse(slow);
            fast = head;
            // 进行判断
            while (slow != null && fast != null)
            {
                if (slow.val != fast.val)
                {
                    return false;
                }
                slow = slow.next;
                fast = fast.next;
            }
            return true;
        }
    
        private ListNode reverse(ListNode head)
        {
            ListNode cur = head;
            ListNode prev = null;
            while (cur != null)
            {
                ListNode next = cur.next;
                cur.next = prev;
                prev = cur;
                cur = next;
            }
            return prev;
        }
    

  • 237 Delete Node in a Linked List

    • stupid problem
• 2020-02-26

  • 876 Middle of the Linked List

    • 利用快慢指针,当快指针走到末尾的时候,慢指针刚好走到中间位置 ,既 index>>1 的位置

    public static ListNode middleNode(ListNode head)
        {
            if (head == null) return null;
            ListNode fast = head.next;
            ListNode slow = head;
            int linkCount = 2;
            while (true)
            {
                if (fast == null) break;
                if (fast.next == null)
                {
                    linkCount += 1;
                    break;
                }
                fast = fast.next.next;
                slow = slow.next;
                if (fast != null)
                {
                    linkCount += 2;
                }
            }
    
            if (linkCount % 2 == 0)
            {
                return slow;
            }
    
            return slow.next;
        }
    
    

• 1290 Convert Binary Number in a Linked List to Integer

  • 可以通过反转再根据byte数组的形式实现,获取长度即可

  • 大神的思路: 直接用或运算即可 ,其实不需要考虑 (1<关键是 这个val的值要么为0,要么为1 ,所以我们可以直接通过| 运算构建出这个 0,1数组

    public int getDecimalValue(ListNode head) {
            int ans = 0;
            while (head != null) {
                ans = (ans << 1) | head.val;
                head = head.next;
            }
            return ans;
        }
    

    public static int getDecimalValue(ListNode head)
        {
            head = reverse(head);
            int c = 0;
            int v = 0;
            while (head != null)
            {
                v += head.val * (1 << c);
                head = head.next;
                c++;
            }
    
    
            return v;
        }
    
        private static ListNode reverse(ListNode head)
        {
            ListNode cur = head;
            ListNode prev = null;
            while (cur != null)
            {
                ListNode next = cur.next;
                cur.next = prev;
                prev = cur;
                cur = next;
            }
            return prev;
        }
    

String

• 2020-02-27

  • 13 Roman to Integer

    • 不是很喜欢这种题
    • for循环遍历匹配即可

  • String_14_Longest_Common_Prefix

    • 这题没思路,一直卡在,以为需要自己造轮子,感觉这个轮子好复杂,然后发现可以直接用String.indexOf来逐个

      • 判断即可
      • 也有陷阱,陷阱在题目上,是前缀,不是包含,所以要indexOf==0来判断

• 2020-02-28

  • String_20_Valid_Parentheses:
    • 判断是否是成对出现,类似于判断是否是回文
    • 用栈即可
  • 28_Implement strStr:
    • 卡了,实现自带的String api :indexOf
    • 注意边界条件:
      • 为空
      • hayStack长度小于needle
    • 本质是不停的subString然后进行比较

• 2020-02-29

  • String_58_Length_o_ Last_ Word
    • 获取最后一个单词的长度
  • String_67_Add_Binary_
    • 字符串形式的二进制相加然后返回字符串形式的二进制

• 2020-03-01

  • String 125 Valid Palindrome
    • 陷入了与链表的思路,先获取到slow和fast,然后slow反转再进行判断,但是却忘记了String自带api,可以从后往前,而不是单链表
  • String 157 read n characters given read4
    • 判断调用read4是否返回4即可

• 2020-03-02

  • String_344_Reverse_String
    • 反转字符串,基于数组的特性,直接按照下标交换即可
  • String_345_Reverse_Vowels_of_a_String
    • 交换元音字母(既a,e,i,o,u和A,E,I,O,U)
    • 一左一右移动匹配即可

• 2020-03-03

  • 对于字符串,如果需要遍历并且统计次数的情况,则可以充分考虑26个字符这个潜在条件:既申请长度为26的字符数组,按照字符序进行排序
  • String_383_Ransom_Note
    • 判断ransom是否可以由magazine中的字符组合而成,换句话说可以认为是排列组合的问题,没有顺序的划分
    • 解题关键在于: 为字符串,因此可以申请长度为26的字符数组,该字符数组的value代表重复次数,最后在for循环即可
  • String_387_First_Unique_Character_in_a_String
    • 获取字符串中,不重复的最小下标值
    • 同理,面对需要for循环遍历的字符串,可以重复

• 2020-03-04

  • String_415_Add_Strings

    • 思路就是对字符串的所有值进行相加,字符串有长短之分,因此为了避免,短的到了末尾之后
      用0来代替
      这题忘了,对于字符串相加转数字是由套路的,/10 和%10
      当一个数不停的除以10: 如 12345 不停的除以10 得到的结果是: 1234,123,12,1
      当一个数不停的模10的时候: 如 12345 不停的模10
      

  • String_434_Number_of_Segments_in_a_String

    • 什么时候统计次数会+1:
      当该字符不为空,同时上一个字符为空,代表着是一个新的单词,则++
      

• 2020-03-05

  • String_443_String_Compression_背
    • 题目刚开始理解不了,并且这题感觉并不是easy题
  • String_459_Repeated_Substring_Pattern
    • 刚开始也是没思路

---

• 特殊原因,刷题不知道哪日恢复恢复,人生大事

---

• 2020-03-09

  • 443 String Compression
    • 题目刚开始理解不了,并且这题感觉并不是easy题
  • 459 Repeated Substring Pattern
    • 刚开始也是没思路
    • 核心的就这几点:
      • 必然是 子串长度*n个=字符串长度l

• 2020-03-10

  • 520_Detect_Capital
    • 判断是否是特殊的词
    • 内置api快速解决
  • 521_Longest_Uncommon_Subsequence_I
    • 最开始没理解题意,搜了看了一段时间才明白,只是一道类似于判断长度的题,stupid 问题

---

• 2020-03-12 今天开始,重新恢复刷题

---

• 2020-03-12

  • String_541_Reverse_String_II
    • 有点类似于数学题,唯一需要注意的就是 下标的移动,以及关于限制条件: 小于k 和[k,2k]之间的数据
  • String_551_Student_Attendance_Record_I
    • 好傻的一道题,没做,直接算是跳过的那种

• 2020-03-13

  • String_557_Reverse_Words_in_a_String_III

  • 简单的split之后遍历反转加拼接即可

  • String_606_Construct_String_from_Binary_Tree

    • * 刚开始题意没有理解, 需要注意的就是当左右都为空的时候, 这个限制条件直接插入空的即可
       * 4种情况:
       * 1. 左右都为空,此时直接返回即可
       * 2. 左为空,右不为空,根据先序的规则: 根左右,所以需要 先加上()
       * 3. 左不为空,但是右为空: 则 根据题意,此时直接(+left+)
       * 4. 左右都不为空: 则 ( + left + ) + ( + right + )
      

• 2020-03-14

  • Tree_110_Balanced_Binary_Tree
  • Tree_637_Average_of_Levels_in_Binary_Tree

• 2020-03-15

  • Stack_682_Baseball_Game

     * @Detail 1. 就是看题意解题这种即可,但是被局限于tag 了,既然是stack的标签,因此一直在纠结stack如何实现
     * 其实用队列是最快的,或者说不是队列,而是可以通过下标获取元素的数据结构即可
     * @Attention: 1. linkedlist用peek 而不是用get,原因在于,get会抛出错误,而peek并不会,只会返回null
    

  • Stack_844_Backspace_String_Compare

    • 1. 利用两个栈来取消字符即可
      

Stack

• 2020-03-16

  • Stack_232_Implement_Queue_using_Stacks

    •  * @Detail 两个栈实现队列
       * 栈为先进后出,而要做到先进先出,需要有一个stack专门push,另外一个stack专门pop
       * @Attention: 注意点就是, push的时候要把out的全部移过来, 保证顺序, pop的时候要把in的全部移过来
      

  • Stack_225_Implement_Stack_using_Queues

    •  * @Detail 时刻保持一个队列为空, 另外一个队列有数据即可
       * @Attention: 遇到一个坑, 就是当遍历的时候, 采用的是q1.size ,但是当poll的时候,却忽略了size会变
      

• 2020-03-17

  • Stack_155_Min_Stack

    • 1. 唯一需要注意只有条件中的,以O(1)的时间查找到最小值,意味着需要保存下标或者是最小值
      

  • Stack_496_Next_Greater_Element_I

    * 1. 既 sum1 中的元素为sum2中的子元素
    * 2. 除元素需要大于sum1中的外并且sum2中的下标也需要大于sum1中的下标
    * 3. 并且这个元素需要为 大于这个元素的最小值
    * 
    
    * 并不是存储下标,而是直接存储这个值,也并非是大于这个元素的最小值,大于它的第一个值即可
    * @Detail 1. 最简单的方式是直接2个for循环一个一个匹配
    * 题目没搞懂
    * 存储的不是下标,是元素,但是这道题难度不应该是easy 而应该是medium
    * 未解决
    

``

• 2020-03-18

  • Stack_1021_Remove_Outermost_Parentheses

    •  * 去除最外层的括号对
       * @Detail 没思路
       * 看了别人的其实好像挺简单的,核心就是根据要求,既然 () 是成对出现的,则意味着最终 ( 和 ) 的数量会一致
      

  • Stack_1047_Remove_All_Adjacent_Duplicates_In_String

    • 移除相连的元素,
       * @Detail 题目没理解, 刚开始理解为删除直至成为回文字符串, 并不是, 而是一直不停地删除, 知道剩下的元素不是相同的
       * 1. 解题思路就是很明确,用栈,如果与之前的相同,则把之前的弹出(此时栈中还存着以前的数据,并且题目要求相邻)
      

• 2020-03-19

  • Queue_346_Moving_Average_from_Data_Stream

  •  初始化一个滑动窗口,大小为w,输入一系列数,
    * 求窗口内的平均数,窗口会向前滑动,当窗口填满时,将最早进入的数弹出,加入新的数.
    * 然后对余下的数作平均值计算即可
    

  • Queue_933_Number_of_Recent_Calls

      ```
      * 题目没看懂
      * 既统计值在[t-3000,t]范围内的次数
      ```
    

• 2020-03-20

  • HashTable_299_Bulls_and_Cows

    * 既然数字在0-9 ,所以可以定义一个int[10]的数组,
    index对应的值则为是否存在,secret ++ <0 代表 guess中存在这个值
    * guess-- >0 代表secret中存在这个值
    

---

• 2020-03-20 16:52 刷题取消一段时间
• 2020-04-01 16:33 刷题暂时缩减到每天1道,有其他安排~

---

HashTable

• 2020-04-01

  • HashTable_204_Count_Primes

    • 求质数,方法就是笨一点的类乘,如果值在n范围内,则说明那个值不是质数
      

• 2020-04-02

  • HashTable_136_Single_Number

  •       返回只出现一次的元素
          巧妙利用 `异或`运算符 : 相等的话则值为1否则为0 
          => 0 ^ 2 ^ 1 ^ 4 ^ 5 ^ 2 ^ 4 ^ 1
          
          => 0^ 2^2 ^ 1^1 ^ 4^4 ^5 
          => 0 ^ 0 ^ 0 ^ 0 ^ 5
          
          => 0 ^ 5
          
          => 5 :)
    

• 2020-04-03

  • HashTable_202_Happy_Number

    • 核心只有: 如何将一个数按位数拆分: 789-> 7,8,9
      while (n > 0)
      {
        remain = n % 10;
        squareSum += remain * remain;
        n /= 10;
      }
      

• 2020-04-04

  • HashTable_205_Isomorphic_Strings

    • 解题的关键就是需要记录 字符与下标的关系,并且同一个字符下标要保持不变
      所以可以使用map或者数组(因为ascii有256个字符)
      

• 2020-04-07

  • HashTable_242_Valid_Anagram

    • 1. 排序 ,然后一个一个匹配即可
      * 2. 两个for循环遍历匹配
      * 3. 基于字符串的特性,判断是否包含,可以通过一个++ 一个-- 的形式 最终判断
      

• 2020-04-08

  • Top100_Easy_70_Climbing_Stairs

    • 动态规划题,并且不应该是easy题
      

• 2020-04-09 : 项目繁忙,没时间写

• Too100_Easy_198_House_Robber:

  • 动态规划问题,dp 一直很弱

• 2020-04-11: 刷到树相关的题了,最近要先复习树了