Leetcode刷题思路及代码记录:[No.50——No.100]

No.50：Pow(x, n)
题意：实现一个Pow(x, n)，进行x的n次方操作
思路：分情况处理，为了削减复杂度。

• 当n==0时，return 1;
• 当n < 0时，return的是Pow(x,-n)的倒数；
• 当n >0时，
  • 如果是偶数，return Pow(x*x,n/2)的数
  • 如果是奇数，return x * Pow(x,n-1)的数，然后继续进行递归，直到n为0结束循环

  class Solution:
    def myPow(self, x, n):
        if n == 0:
            return 1
        if n < 0:
            return 1 / self.myPow(x,-n)
        if n % 2 == 1:
            return x * self.myPow(x,n - 1)
        else:
            return self.myPow(x*x,n/2)

  No.53：Maximum Subarray
  思路：给定一个数组，求它的最大连续子序列之和
  如果数组为空，直接返回0
  非空时，先记录cursum = maxsum = nums[0]，
  一个记录最大sum，一个记录当前sum。
  然后循环读入num，每次计算num+cursum和cursum哪个大，更新cursum的值。
  这一步决定是继续上个数组还是另起炉灶
  然后取maxsum和cursum的最大值，更新maxsum的值
  最终的maxsum就是最大连续子序列之和

  class Solution:
    def maxSubArray(self, nums):
        if not nums:
            return 0
        cursum = maxsum = nums[0]
        for num in nums[1:]:
            cursum = max(num,cursum + num)
            maxsum = max(cursum,maxsum)
        return maxsum

No.58：Length of Last Word
思路：题意为获取最后一个单词的长度，如果末尾出现空格，则返回前面单词的长度，主要要处理末尾空格的问题
首先，如果s为空，直接返回0
非空情况下，走一个循环，如果s[i]!=“ ”，res++；
如果s[i]==“ ”且s[i+1]!=“ ”，这种情况下res = 0,更新res的值

class Solution:
    def lengthOfLastWord(self, s):
        if not s:
            return 0
        res = 0
        for i in range(len(s)):
            if s[i] != " ":
                res += 1
            elif i + 1 <= len(s) - 1 and s[i+1] != ' ':
                res = 0
        return res

No.66：Plus One
思路：给定一个数组，代表一个数的每一位，模拟+1后的数字
首先，把数组转为数字，然后+1，把转换后的数字重新转为数组并输出

class Solution:
    def plusOne(self, digits):
        res = [];num = 0
        for i in digits:
            num = num * 10 + i
        num += 1
        while num != 0:
            res.append(num % 10)
            num = num // 10
        res.reverse()
        return res

No.67：Add Binary
思路：题意给定两个个二进制的str,相加后以二进制输出
先把二进制转为十进制，然后相加后再转为二进制输出
或者利用规则，做二进制加法后直接输出

#利用pythonAPI进行计算的版本
class Solution:
    def addBinary(self, a, b):
        a = int(a,2)#转二进制int
        b = int(b,2)#转二进制int
        res = a + b
        return str(bin(res))[2:]#去除0b后输出

#更简短API计算的版本
class Solution:
    def addBinary(self, a, b):
        return bin(eval("0b"+a)+eval("0b"+b))[2:]

#不利用API计算版本
class Solution:
    def addBinary(self, a, b):
        if len(a) == 0:
            return b
        if len(b) == 0:
            return a
        if a[-1] == '1' and b[-1] == '1':#末尾都为1相加
            return self.addBinary(self.addBinary(a[0:-1],b[0:-1]),'1') + '0'
        if a[-1] == '0' and b[-1] == '0':#末尾都为0相加
            return self.addBinary(a[0:-1],b[0:-1]) + '0'
        else:
            return self.addBinary(a[0:-1],b[0:-1]) + '1'    

No.69：Sqrt(x)
题意：实现一个开方函数，可以用二分法不断逼近
思路：首先，表明起始点begin = 0;end = x；表明res = 1。判断如果x<2,直接输出x；x>2时，判断res是否等于x，如果不相等，反复执行下列操作：
中间mid = (begin + end) / 2 res = mid * mid。如果res > x时，在左边寻找；当res < x时，在右边寻找，直到res == x，最后返回mid的int值

class Solution:
    def mySqrt(self, x):
        begin = 0;end = x
        res = 1
        if x < 2:
            return x
        while abs(res - x) > 0.01:
            global mid#声明为全局变量
            mid = (begin + end) / 2
            res = mid * mid
            if res > x:
                end = mid
            else:
                begin = mid
        return int(mid)

No.70：Climbing Stairs
题意：为有n阶台阶，每次能上1个或2个台阶，问有多少种上楼梯的方式。

• 思路1：记忆化搜索
  采用递归方式，如果i>n时，输出0；i==n时，输出1；否则结果应该为climb(i+1,n,ans)+climb(i+2,n,ans)，并把结果保存在ans数组中。当ans[i]>0时，直接调用结果输出，这种情况下可以大幅度降低时间复杂度，减少了很多无用的运算。

class Solution:
    def climbStairs(self, n):
        ans = []
        for i in range(n+1):
            ans.append(0)
        return self.climb(0,n,ans)
    
    def climb(self,i,n,ans):
        if i > n:
            return 0
        if i == n:
            return 1
        if ans[i] > 0:
            return ans[i]
        ans[i] = self.climb(i+1,n,ans) + self.climb(i+2,n,ans)
        return ans[i]

• 思路2：动态规划
  通过思考可知，第i个阶梯由第i-1个阶梯步数 + 第i-2个阶梯步数组成，所以ans[i] = ans[i-1] + ans[i-2]，而且ans[1] = 1；ans[2] = 2，然后直接把ans[n]返回出去。注意数组范围为1~n，所以要注意数组上下界。

class Solution:
    def climbStairs(self, n):
        ans = [0] * (n+2)
        ans[1] = 1
        ans[2] = 2
        for i in range(3,n+1):
            ans[i] = ans[i-1] + ans[i-2]
        return ans[n]

No.83：Remove Duplicates from Sorted List
题意：给定一长串链表数组，去除掉中间重复的元素
思路：先定义一个指针指向head结点，然后往返cur,当cur下个结点存在且相邻两个元素值相等时，指针跳过这个值连接；否则就更新cur的下一个位置，使指针指向下一个位置

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def deleteDuplicates(self, head):
        cur = head
        while cur:
            while cur.next and cur.next.val == cur.val:#如果下面链表存在且相邻两个元素的值相等
                cur.next = cur.next.next#指针跳过这个值
            cur = cur.next#指针指向下一位置
        return head#返回head结点

No.88：Merge Sorted Array
题意： 把B数组前n个数merge到A数组前m个数
思路：当m与n>0时，循环且比较num1[m-1]与num2[n-1],并把较大的放在后面.，并对m和n进行处理。这样，经过一轮循环后，就能使前面的数从小到大排序。然后，如果n还是正数，就把nums1[:n] = nums2[:n]，此时的nums1就是merge后的数组。

class Solution:
    def merge(self, nums1, m, nums2, n):
        while m > 0 and n > 0:
            if nums1[m-1] >= nums2[n-1]:
                nums1[m+n-1] = nums1[m-1]
                m -= 1
            else:
                nums1[m+n-1] = nums2[n-1]
                n -= 1
        if n > 0:
            nums1[:n] = nums2[:n]

No.100.：Same Tree
题意：给定两个树，比较他们是否是相同的树
思路：通过递归确定节点上的两子树是否相同，然后递归左子树和右子树是否相同，如果相同则return p == q

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSameTree(self, p, q):
        if p and q:
            return p.val == q.val and self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)
        return p == q

转载于:https://www.cnblogs.com/EchoWorld/p/9100889.html