LeetCode刷题 2019.9.8

第108题 将有序数组转换成二叉搜索树

这道题主要是将数组分成一个二叉树，用递归的方式，每次一半一半的给：

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        if not nums:
            return None
        else:
            num1 = len(nums)//2
            tn = TreeNode(nums[num1])
            nums1=nums[0:num1]
            nums2=nums[(num1+1):len(nums)]
            tn.left = self.sortedArrayToBST(nums1)
            tn.right = self.sortedArrayToBST(nums2)
        return tn

第110题 平衡二叉树

用递归一层层计算树节点的数量

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        self.res = True
        def helper(root):
            if not root:
                return 0 
            left = helper(root.left) + 1
            right = helper(root.right) + 1
            print(left,right)
            if abs(left-right) > 1:
                self.res = False
            return max(left, right)
        helper(root)
        return self.res

第111题 二叉树的最小深度

利用递归的方法，定义一个子树和最小深度，每次遍历子树并且比较最小值：

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        children = [root.left, root.right]
        if not any(children):
            return 1
        min_depth = float('inf')
        for c in children:
            if c:
                min_depth = min(self.minDepth(c), min_depth)
        return min_depth + 1

第112 路径总和

本题是用递归方式去做，用总和剪去每个节点的值：

class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if not root:
            return False
        sum -= root.val
        #print(sum)
        if not root.left and not root.right:
            return sum == 0
        #self.hasPathSum(root.right, sum)        
        return self.hasPathSum(root.right, sum) or self.hasPathSum(root.left, sum)

第118题 杨辉三角

本题用两次循环的方式，将上一次的两个值加起来给下一行。

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        if numRows == 0:
            return []
        if numRows == 1:
            return [[1]]
        if numRows == 2:
            return [[1],[1,1]]
        if numRows >= 3:
            rows = [[1], [1,1]]
            for i in range(3, numRows+1):
                rowi = [0] * i
                rowi[0] = 1
                rowi[-1] = 1                
                for j in range(1, i-1):
                    rowi[j] = rows[i-2][j-1] + rows[i-2][j]
                rows.append(rowi)
            return rows

第119题 杨辉三角2

先得到类似于上一行，然后根据上一层得到当前一行：

class Solution:
    def getRow(self, rowIndex: int) -> List[int]:
        tmp = []
        for _ in range(rowIndex + 1):
            tmp.insert(0,1)
            #print(tmp)
            for i in range(1, len(tmp) - 1):
                tmp[i] = tmp[i] + tmp[i+1]
        return tmp

第121题 买卖股票的最佳时机

最高价格减去最低价格能得到最高利润，分别定义俩便得到了最高最低价格，一次遍历便能得到最大利润：

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices) <= 1:
            return 0
        max_p = 0
        min_p = prices[0]
        for i in range(len(prices)):
            min_p = min(min_p, prices[i])
            max_p = max(max_p, prices[i]- min_p)
        return max_p

第122题 买卖股票的最佳时机2

这次就涉及到多次买卖的问题，用贪心算法，只要能盈利就卖，可以得到最大利润：

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

第125题 验证回文串

因为空格也算字符串，而标点符号并不算，而且大小写无关，先全部大写或小写，再将标点符号去掉，然后用字符串比较：

class Solution:
    def isPalindrome(self, s: str) -> bool:
        s_1 = s.upper()
        s_2 = "".join(filter(str.isalnum, s_1))
        return str(s_2)==str(s_2)[::-1]

第136题 只出现一次的数字

位操作可以将相同的数变为0，a^a=0，和0与为a：

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        a=0
        for i in range(len(nums)):
            a = a^nums[i]
        return a

set函数是去除重复的元素，所以用2倍的元素减去列表便可以得到单独的值：

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        nums_sum = sum(set(nums))
        return 2*nums_sum - sum(nums)

第141题 环形链表

这题c++编写的不会，以后看：

class Solution {
public:
    bool hasCycle(ListNode *head) {
        set< ListNode *>p_set;
        ListNode *p=head;
        while(p){
            if(p_set.find(p)!=p_set.end())
                return true;
            p_set.insert(p);
            p=p->next;
        }
        return false;
    }
};