Leetcode每天五题II-02

29. 两数相除

给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。

返回被除数 dividend 除以除数 divisor 得到的商。

示例 1:

输入: dividend = 10, divisor = 3
输出: 3

示例 2:

输入: dividend = 7, divisor = -3
输出: -2

class Solution(object):
    def divide(self, dividend, divisor):
        bound = 2**31
        if dividend == -bound and divisor == -1:
            return bound-1
        is_pos = dividend ^ divisor >= 0
        dd,dr = abs(dividend),abs(divisor)
        res = 0
        for i in range(31,-1,-1):
            if dd >> i>=dr:
                res += 1<<i
                dd -= dr<<i
        return res if is_pos else -res

41. 缺失的第一个正数

给定一个未排序的整数数组，找出其中没有出现的最小的正整数。

示例 1:

输入: [1,2,0]
输出: 3

示例 2:

输入: [3,4,-1,1]
输出: 2

示例 3:

输入: [7,8,9,11,12]
输出: 1

说明:

你的算法的时间复杂度应为O(n)，并且只能使用常数级别的空间。

class Solution(object):
    def firstMissingPositive(self, nums):
        l,r = 0,len(nums)
        while l<r:
            if nums[l]==l+1:
                l+=1
            elif nums[l]<=l or nums[l]>r or nums[nums[l] -1]==nums[l]:
                r-=1
                nums[l] = nums[r]
            else:
                # 交换顺序有坑
                t=nums[nums[l]-1]
                nums[nums[l]-1] = nums[l] 
                nums[l] = t
        return l+1

50. Pow(x, n)

实现 pow(x, n) ，即计算 x 的 n 次幂函数。

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

66. 加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

class Solution(object):
    def plusOne(self, digits):
        i,l = -1,len(digits)
        while i >= -l and digits[i]==9:
            digits[i]=0
            i-=1
        if i == -l-1:
            digits.insert(0,1)
        else:digits[i]+=1
        return digits

103. 二叉树的锯齿形层次遍历

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

思路：

使用两个栈，当前层是奇数则下一层先压右子树，否则先压左子树

class Solution(object):
    def zigzagLevelOrder(self, root):
        if not root:
            return []
        i = 0
        res = []
        s = [[],[]]
        s[i].append(root)
        while len(s[0]) or len(s[1]):
            ans = []
            while len(s[i]):
                node = s[i].pop()
                ans.append(node.val)
                if i:
                    if node.right:
                        s[not i].append(node.right)
                    if node.left:
                        s[not i].append(node.left)
                else:
                    if node.left:
                        s[not i].append(node.left)
                    if node.right:
                        s[not i].append(node.right)
            res.append(ans)
            i = not i
        return res