【2021/4/10 刷题笔记】Leetcode之容易等级题

# 2021/4/10

目录

3的幂

【题目】

【我的方法】

执行结果：

【其他方法】

执行结果：

回文链表

【题目】

【我的方法】

执行结果#1：

执行结果#2：

【其他方法】

执行结果：

 

【整理之快慢指针】

何为快慢指针

1、找中间值

2、判断链表中的环

3、删除倒数第n个节点

---

3的幂

【题目】

给定一个整数，写一个函数来判断它是否是 3 的幂次方。如果是，返回 true ；否则，返回 false 。

整数 n 是 3 的幂次方需满足：存在整数 x 使得 n == 3x

示例 1：

输入：n = 27
输出：true
示例 2：

输入：n = 0
输出：false

提示：

-231 <= n <= 231 - 1

进阶：

你能不使用循环或者递归来完成本题吗？

【我的方法】

循环。。。

class Solution:
    def isPowerOfThree(self, n: int) -> bool:
        i = 1
        while(i<n):
            i *= 3
        if i!=n:
            return False
        else:
            return True

执行结果：

执行用时：92 ms, 在所有 Python3 提交中击败了66.06%的用户

内存消耗：14.8 MB, 在所有 Python3 提交中击败了72.25%的用户

【其他方法】

@水滴 的评论：

通过查看相关解析，发现了这个解法，用到了数论的知识，3的幂次的质因子只有3，而所给出的n如果也是3的幂次，故而题目中所给整数范围内最大的3的幂次的因子只能是3的幂次，1162261467是3的19次幂，是整数范围内最大的3的幂次。

# 借鉴该思路的代码：
class Solution:
    def isPowerOfThree(self, n: int) -> bool:
        return n>0 and 1162261467%n == 0

执行结果：

执行用时：92 ms, 在所有 Python3 提交中击败了66.06%的用户

内存消耗：14.9 MB, 在所有 Python3 提交中击败了15.60%的用户

---

回文链表

【题目】

请判断一个链表是否为回文链表。

示例 1:

输入: 1->2
输出: false
示例 2:

输入: 1->2->2->1
输出: true
进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

【我的方法】

1、利用栈暴力解决

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        if not head.next:
            return True

        n = 1
        temp = head
        while(temp.next):
            temp = temp.next
            n += 1
        # print(n)
        if n == 2:
            if head.val!= head.next.val:
                return False
            else:
                return True
        
        temp = head
        stack = []
        i = 0
        while(i<n//2):
            stack.append(temp.val)
            temp = temp.next
            i += 1
        print(stack)
        if n%2!=0:
            temp = temp.next
        while(temp):
            a = stack.pop()
            # print(a,temp.val)
            if temp.val != a:
                return False
            temp = temp.next
        return True

执行结果#1：

执行用时：1056 ms, 在所有 Python3 提交中击败了5.09%的用户

内存消耗：48.6 MB, 在所有 Python3 提交中击败了11.27%的用户

2、利用链表的生成方式（前向插入），减小空间复杂度：

如链表1->2->3->4->5：

1）先找出中节点3，然后pre指向3，temp指向后面的4

2）开始创建一条新链表，即反转后半截链条，具体思路如下图：

3）两条链条进行比对

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        if not head.next:
            return True

        n = 1
        temp = head
        while(temp.next):
            temp = temp.next
            n += 1
        
        if n == 2:
            if head.val!= head.next.val:
                return False
            else:
                return True
        
        i = 0
        pre = head
        while(i<n//2-1):
            pre = pre.next
            i += 1
        if n%2!=0:
            pre = pre.next
        temp = pre.next
        
        head2 = ListNode()
        while(temp):
            pre.next = temp.next
            temp.next = head2.next
            head2.next = temp
            temp = pre.next
        
        while(head2.next):
            if head2.next.val != head.val:
                return False
            head2 = head2.next
            head = head.next
        return True

执行结果#2：

执行用时：808 ms, 在所有 Python3 提交中击败了27.55%的用户

内存消耗：40.3 MB, 在所有 Python3 提交中击败了40.18%的用户

【其他方法】

@Albert 的评论也是类似的思路：

其一，find mid node 使用快慢指针找到链表中点。

其二，reverse 逆序后半部分。

其三，check 从头、中点，开始比较是否相同。

# 借鉴其思路整理出的代码
class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        if not head.next:
            return True

        slow = head
        fast = head
        prev = None

        while(fast): # find mid node
            slow = slow.next
            if fast.next:
                fast = fast.next.next
            else:
                fast = fast.next
        
        while(slow): # reverse
            temp = slow.next
            slow.next = prev
            prev = slow
            slow = temp
        
        while(head and prev): # check
            if head.val!= prev.val:
                return False
            head = head.next
            prev = prev.next
        return True

执行结果：

执行用时：720 ms, 在所有 Python3 提交中击败了44.51%的用户

内存消耗：40.3 MB, 在所有 Python3 提交中击败了40.93%的用户

 

【整理之快慢指针】

何为快慢指针

快慢指针就是定义两根指针，移动的速度一快一慢，以此来制造出自己想要的差值。这个差值可以让我们找到链表上相应的节点。

1、找中间值

一般的思路是：先遍历一次链表，记录住一共有多少个节点，然后，再次遍历找寻中点。

利用快慢指针，我们来看看这个问题会变成什么样。思路如下：我们把一个链表看成一个跑道，假设a的速度是b的两倍，那么当a跑完全程后，b刚好跑一半，以此来达到找到中间节点的目的。

最开始，slow与fast指针都指向链表第一个节点，然后slow每次移动一个指针，fast每次移动两个指针。

2、判断链表中的环

还是把链表比作一条跑道，链表中有环，那么这条跑道就是一条圆环跑道，在一条圆环跑道中，两个人有速度差，那么迟早两个人会相遇，只要相遇那么就说明有环。

快慢指针中，因为每一次移动后，快指针都会比慢指针多走一个节点，所以他们之间在进入环状链表后，不论相隔多少个节点，慢指针总会被快指针赶上并且重合，此时就可以判断必定有环。

3、删除倒数第n个节点

删除倒数第n个节点，那就等于是要我们先找出待删除元素前一个元素，也就是第n-1个节点。又把这个问题转化为找链表上的某个节点的问题，这是快慢指针最擅长的场景。

那如何找第(n-1)个元素呢？我们一开始就让fast指针比slow指针快n+1个元素，接下来，两个指针都是一步一步来往下走。那么当fast指针走完时，slow指针就刚刚好停留在第(n-1)个元素上。

（参考自：https://www.jianshu.com/p/21b4b8d7d31b）