Leetcode刷题日记（含简单的思路）

消除重复项,合并区间：

例如：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
​

class Solution(object):
    def merge(self, intervals):
        intervals.sort()  #对输入的列表进行排序
        he = [intervals[0]]    #保存第一个数组并生成列表
        for i in intervals[1:]:    
            if he[-1][1] >= i[0]:   #如果新列表中最后一个数组的第2位大于后一个数组的第1位，将新列表中的进行替换
                 he[-1][1] = max(i[1], he[-1][1])  
            else:
                he.append(i)    #否则，直接无条件的添加
        return he

思路：合并是前一个数组的第二个数据大于第后一个数组的第一个数据，判断是否大于，大于的话进行合并并插入新的数组中，否则，直接进行插入。新数组首先存入第一个数组为参照，然后每次判断取最后一个数组进行比较。

python的数组的水平翻转：

intervals[::] = intervals[::-1]

python的逆时针翻转90：

给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。

for i in range(len(matrix)):
            for m in range(i):
                matrix[i][m],matrix[m][i] = matrix[m][i],matrix[i][m]   #对角线翻转
        
        for h in range(len(matrix)):
            matrix[h][::] = matrix[h][::-1]

逆时针翻转，对角线翻转，在水平翻转就是逆时针翻转的效果。

最长的公共前缀：

示例 1：

输入：strs = ["flower","flow","flight"]
输出："fl"

class Solution(object):
    def longestCommonPrefix(self, strs):
        if len(strs) == 0:    #如果为空字符串，则返回''
                    return ''
        res = ''    #用于存放
        for i in range(len(strs[0])):   #以第一个字符串的大小为循环的参照
            for str in strs:           #遍历列表中的每一个字符串
                if len(str) <= i:       #如果小于i,当前的个数， <=,因为是从0开始的，数字从1开始的
                    return res               #                    所以有等于号（特别注意）
                else:
                    if str[i] != strs[0][i]:    #或者字符串中的第i位与第一个字符串中的第i位不相等
                        return res               #直接返回
            res += strs[0][i]       #遍历strs，处理不在其他中或其他字符串过短的问题，
        return res

直接取得第一个数据为参照，以它长度进行循环，如果有字符串小于当前的i，那么最长公共前缀不可能更大，直接放回，否则，判断当前字符串是否相等，不相等就直接返回，否则就存入res中并继续进行遍历。

中心元素的下标：

  all = sum(nums)   #求和
        t = 0
        for i in range(len(nums)):  
            if t * 2 + nums[i] == all:   #判断左边的2倍加上中间的数是否等于sum,如果不存在，就查找失败
                return i 
            else:
                t += nums[i]    #前i项和存入t中
​
        return -1

中心元素就是两边的数加起来等于0，那么中心元素的左半边的2倍在加上中心元素应该等于总和。

零矩阵 编写一种算法，若M × N矩阵中某个元素为0，则将其所在的行与列清零。

示例 1：

输入： [ [1,1,1], [1,0,1], [1,1,1] ] 输出： [ [1,0,1], [0,0,0], [1,0,1] ]

class Solution(object):
    def setZeroes(self, matrix):
        x_zero = []
        y_zero = []
        l = len(matrix)
        s = len(matrix[0])
        for i in range(l):
            for m in range(s):
                if matrix[i][m] == 0:
                    x_zero.append(i)
                    y_zero.append(m)
        for i in range(l):
            if i in x_zero:
                for d in range(s):
                    matrix[i][d] = 0
​
        for i in range(s):
            if i in y_zero:
                for e in range(l):
                    matrix[e][i] = 0

通过循环找出为0的数据并保存其x,y坐标，然后再将x，y的那一横,纵分别全部变成0，

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = "babad" 输出："bab" 解释："aba" 同样是符合题意的答案。

class Solution:
    def longestPalindrome(self, s: str) -> str:
        """
        回文串:正读和反读都一样的字符串(可以理解为对称的字符串)
        思路: 1 分为奇数串('aba')和偶数串(’abba‘)两种情况
             2 把每个字符当做回文串中间的字符，由内向外延展比较
                (定义由内向外的两个索引值)
        """
        res = ""
        for i in range(len(s)):
            # 奇数情况
            tmp = self.helper(s, i, i)
            if len(tmp) > len(res):
                res = tmp              #res不断的进行迭代，将最长的字符串保存到res里面
            # 偶数情况
            tmp = self.helper(s, i, i+1)
            if len(tmp) > len(res):
                res = tmp
        return res
    
    def helper(self, s, l, r):    
        while l >=0 and r < len(s) and s[l]==s[r]:
            l -= 1; r += 1
        return s[l+1:r]
​

给你一个字符串 s ，颠倒字符串中 单词 的顺序。

示例 2：

输入：s = "  hello world  "
输出："world hello"
解释：颠倒后的字符串中不能存在前导空格和尾随空格。

class Solution(object):
    def reverseWords(self, s):
        s1 = ' '.join(s.split()[::-1])
        return s1

' '.join(），可以去除多于的空格，split()[::-1]，加上前面的就是以空格数据依据，进行倒叙

最大字数组和：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

class Solution(object):
    def maxSubArray(self, nums):
        size = len(nums)
        if size == 0:
            print(0)
        dp = [0 for _ in range(size)]    #创建一个长度为len的数组
​
        dp[0] = nums[0]    #将第一个数据赋值给第一个
        for i in range(1, size):
            if dp[i - 1] >= 0:     #如果前面的数据和大于0，就加起来存进去
                dp[i] = dp[i - 1] + nums[i]
            else:
                dp[i] = nums[i]    #否则直接存进去
        return max(dp)

思路：累计最大，以前面为标准，如果前面的和为负数，会拉小数据，不加进去，直接保存当前 i 的数据，大于0则将数据加进去，最后求最大