Leetcode笔记一：数组和字符串

一、数组和字符串

No_1：#寻找数据中心索引，数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和，不存在返回-1

    def pivotIndex( nums) -> int:
        if len(nums) == 0:
            return -1
        elif len(nums) == 1:
            return nums[0]
        else:
            sum_left = 0
            sum_right = sum(nums)-nums[0]
            for i in range(len(nums)-1):
                if sum_left == sum_right :
                    return nums[i]
                sum_left += nums[i]
                sum_right -=nums[i+1]
                if i == len(nums)-2:
                    return -1

No_2:#查找数组中的最大元素是否至少是数组中每个其他数字的两倍。

    def dominantIndex(nums) -> int:  #思路：最大数是不是第二大数的2倍
        the_largest = 0
        the_secondery = 0
        the_index = 0
        for i in range(len(nums)):
            if nums[i] > the_largest:
                the_secondery = the_largest
                the_largest = nums[i]
                the_index = i
            elif nums[i] > the_secondery:
                the_secondery = nums[i]

        if the_largest >= 2 * the_secondery:
            return the_index
        else:
            return -1

No_3:#给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

    def plusOne(digits) :
        l = len(digits)
        i = l-1
        carryBit = 1
        while i >=0 :
            digits[i] += carryBit
            if digits[i] == 10 :
                digits[i] = 0
                carryBit = 1
            else:
                carryBit = 0
            i -=1
        if carryBit == 1:
            digits.insert(0,1)
        return digits

No_4:#给定一个含有 M x N 个元素的矩阵（M 行，N 列），请以对角线遍历的顺序返回这个矩阵中的所有元素

    def findDiagonalOrder(matrix): # 对角线有两个方向，向上向下，还有就是到边界后是y+1还是x+1
        if not matrix:
            return []
        m=len(matrix)
        n=len(matrix[0])
        x,y = 0,0
        s = []
        s.append(matrix[x][y])
        while True :
            if y < n-1:
                y+=1
            elif x< m-1:
                x+=1
            else:
                break
            s.append(matrix[x][y])
            while x < m-1 and y > 0:
                x += 1
                y -=1
                s.append(matrix[x][y])
            if x< m-1:
                x+=1
            elif y< n-1:
                y+=1
            else :
                break
            s.append(matrix[x][y])
            while x>0 and y<n-1 :
                x -=1
                y +=1
                s.append(matrix[x][y])

        return s

No_5:#给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

    def spiralOrder(matrix):  #循环中注意一个是方向问题，一个是循环结束条件
        if not matrix:
            return []
        m=len(matrix)
        n=len(matrix[0])
        x,y = 0,-1
        s = []
        i = 1
        step=n

        while True:
            if i%2 ==1:
                t = 1
            else:
                t = -1
            step = n+1-i
            if step == 0:
                break

            for a in range(step):
                y+=t
                s.append(matrix[x][y])

            step = m-i
            if step == 0:
                break

            for a in range(step):
                x+=t
                s.append(matrix[x][y])
            i += 1
        return s

No_6:#给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

  def generate(numRows):
        if numRows == 0:
            return []
        s=[]
        for x in range(numRows):
            s0 = [1]*(x+1)
            for y in range(x+1):   #改进一下：range（1，x）直接去掉首尾，去掉下面if判断

                if y ==0 or y==x:
                    pass
                else:
                    s0[y]= s[x-1][y-1]+s[x-1][y]
            s.append(s0)

        return s