victory的博客

长安一片月,万户捣衣声

0%

448.找到所有数组中消失的数字

题目描述

给你一个含 n 个整数的数组 nums ,其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字,并以数组的形式返回结果。

示例 1:
输入:nums = [4,3,2,7,8,2,3,1]
输出:[5,6]

题目链接

思路

可以通过集合求差集的方式实现
set1 = {4,3,2,7,8,2,3,1}
set2 = {1,2,3,4,5,6}
set2 - set1即为题目所求

代码

class Solution(object):
    def findDisappearedNumbers(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        # 超出时间限制
        # result = []
        # for i in range(1, len(nums)+1):
        #     if i not in nums:
        #         result.append(i)
        # return result

        # 超出时间限制
        # return [i for i in range(1, len(nums)+1) if i not in nums]

        # 集合求差集
        set1 = set(nums)
        set2 = set([i for i in range(1, len(nums) + 1)])
        return list(set2.difference(set1))


if __name__ == "__main__":
    slt = Solution()
    nums = [4, 3, 2, 7, 8, 2, 3, 1]
    result = slt.findDisappearedNumbers(nums)
    print(result)

338.比特位计数

题目描述

给你一个整数 n ,对于 0 <= i <= n 中的每个 i ,计算其二进制表示中 1 的个数 ,返回一个长度为 n + 1 的数组 ans 作为答案。

示例 1:
输入:n = 2
输出:[0,1,1]
解释:
0 –> 0
1 –> 1
2 –> 10

题目链接

思路

我的题解

代码

class Solution(object):
    def countBits(self, n):
        """
        :type n: int
        :rtype: List[int]
        """
        # result = []
        # for i in range(0, n+1):
        #     result.append(bin(i).count('1'))
        # return result

        return [bin(i).count('1') for i in range(0, n+1)]

461.汉明距离

题目描述

两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目。
给你两个整数 x 和 y,计算并返回它们之间的汉明距离。

示例 1:
输入:x = 1, y = 4
输出:2
解释:
1 (0 0 0 1)
4 (0 1 0 0)
↑ ↑
上面的箭头指出了对应二进制位不同的位置。

题目链接

思路

我的题解

代码

class Solution(object):
    def hammingDistance(self, x, y):
        """
        :type x: int
        :type y: int
        :rtype: int
        """
        return bin(x ^ y).count('1')


if __name__ == "__main__":
    # # 十进制转二进制:bin(10)
    # print(bin(10))
    # # 十进制转八进制:oct(10)
    # print(oct(10))
    # # 十进制转十六进制:hex(10)
    # print(hex(10))
    #
    # # 二进制转十进制:int("1010",2)
    # print(int("1010", 2))
    # # 八进制转十进制:int("0o12",8)
    # print(int("0o12", 8))
    # # 十六进制转十进制:int("0xa",16)
    # print(int("0xa", 16))
    
    # print(str(bin(1 ^ 4)).count('1'))
    # print(str(bin(3 ^ 1)).count('1'))
    
    slt = Solution()
    result = slt.hammingDistance(1, 4)
    print(result)

617.合并二叉树

题目描述

给你两棵二叉树: root1 和 root2 。
想象一下,当你将其中一棵覆盖到另一棵之上时,两棵树上的一些节点将会重叠(而另一些不会)。你需要将这两棵树合并成一棵新二叉树。合并的规则是:如果两个节点重叠,那么将这两个节点的值相加作为合并后节点的新值;否则,不为 null 的节点将直接作为新二叉树的节点。
返回合并后的二叉树。
注意: 合并过程必须从两个树的根节点开始。

示例 1:
输入:root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出:[3,4,5,5,4,null,7]

题目链接

思路

  1. 深度优先搜索
    使用深度优先搜索合并两个二叉树。从根节点开始遍历两个二叉树,并将对应的节点进行合并。

两个二叉树的对应节点可能存在以下三种情况,对于每种情况使用不同的合并方式。
(1)如果两个二叉树的对应节点都为空,则合并后的二叉树的对应节点也为空;
(2)如果两个二叉树的对应节点只有一个为空,则合并后的二叉树的对应节点为其中的非空节点;
(3)如果两个二叉树的对应节点都不为空,则合并后的二叉树的对应节点的值为两个二叉树的对应节点的值之和,此时需要显性合并两个节点。
对一个节点进行合并之后,还要对该节点的左右子树分别进行合并。这是一个递归的过程。
2. 广度优先搜索
使用广度优先搜索合并两个二叉树。首先判断两个二叉树是否为空,如果两个二叉树都为空,则合并后的二叉树也为空,如果只有一个二叉树为空,则合并后的二叉树为另一个非空的二叉树。

如果两个二叉树都不为空,则首先计算合并后的根节点的值,然后从合并后的二叉树与两个原始二叉树的根节点开始广度优先搜索,从根节点开始同时遍历每个二叉树,并将对应的节点进行合并。

使用三个队列分别存储合并后的二叉树的节点以及两个原始二叉树的节点。初始时将每个二叉树的根节点分别加入相应的队列。每次从每个队列中取出一个节点,判断两个原始二叉树的节点的左右子节点是否为空。如果两个原始二叉树的当前节点中至少有一个节点的左子节点不为空,则合并后的二叉树的对应节点的左子节点也不为空。对于右子节点同理。

如果合并后的二叉树的左子节点不为空,则需要根据两个原始二叉树的左子节点计算合并后的二叉树的左子节点以及整个左子树。考虑以下两种情况:
(1)如果两个原始二叉树的左子节点都不为空,则合并后的二叉树的左子节点的值为两个原始二叉树的左子节点的值之和,在创建合并后的二叉树的左子节点之后,将每个二叉树中的左子节点都加入相应的队列;
(2)如果两个原始二叉树的左子节点有一个为空,即有一个原始二叉树的左子树为空,则合并后的二叉树的左子树即为另一个原始二叉树的左子树,此时也不需要对非空左子树继续遍历,因此不需要将左子节点加入队列。
对于右子节点和右子树,处理方法与左子节点和左子树相同。

阅读全文 »

543.二叉树的直径

题目描述

给定一棵二叉树,你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

示例 :
给定二叉树

      1
     / \
    2   3
   / \     
  4   5    

返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。
注意:两结点之间的路径长度是以它们之间边的数目表示。

题目链接

思路

  1. 深度优先搜索
    首先我们知道一条路径的长度为该路径经过的节点数减一,所以求直径(即求路径长度的最大值)等效于求路径经过节点数的最大值减一
    而任意一条路径均可以被看作由某个节点为起点,从其左儿子和右儿子向下遍历的路径拼接得到。

假设我们知道对于该节点的左儿子向下遍历经过最多的节点数 LLL (即以左儿子为根的子树的深度) 和其右儿子向下遍历经过最多的节点数 RRR (即以右儿子为根的子树的深度),那么以该节点为起点的路径经过节点数的最大值即为 L+R+1L+R+1L+R+1 。
我们记节点 node 为起点的路径经过节点数的最大值为 dnode​ ,那么二叉树的直径就是所有节点 dnode​的最大值减一。

算法流程为:我们定义一个递归函数 depth(node) 计算 dnode​,函数返回该节点为根的子树的深度。先递归调用左儿子和右儿子求得它们为根的子树的深度 L 和 R ,则该节点为根的子树的深度即为
max(L,R)+1,该节点的 dnode​值为 L+R+1,递归搜索每个节点并设一个全局变量 ans 记录 dnode​的最大值,最后返回 ans-1 即为树的直径。

代码

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


class Solution(object):
    def diameterOfBinaryTree(self, root):
        """
        这种解法路径必须经过根节点,由题目可知路径可能穿过
        也可能不穿过根节点,故此解法不符合题意
        :type root: TreeNode
        :rtype: int
        """
        left = self.get_depth(root.left)
        right = self.get_depth(root.right)
        return left + right
    
    def get_depth(self, root):
        if not root:
            return 0
        left_depth = self.get_depth(root.left)
        right_depth = self.get_depth(root.right)
        return max(left_depth, right_depth) + 1
    
    def diameterOfBinaryTree1(self, root):
        self.ans = 1
        def depth(node):
            if not node:
                return 0
            L = depth(node.left)
            R = depth(node.right)
            self.ans = max(self.ans, L + R + 1)
            return max(L, R) + 1
        depth(root)
        return self.ans - 1  # 一条路径的长度为该路径经过的节点数减一

if __name__ == "__main__":
    slt = Solution()
    root = TreeNode(1)
    node2 = TreeNode(2)
    node3 = TreeNode(3)
    node4 = TreeNode(4)
    node5 = TreeNode(5)
    root.left = node2
    root.right = node3
    node2.left = node4
    node2.right = node5
    # diameter = slt.diameterOfBinaryTree(root)
    diameter = slt.diameterOfBinaryTree1(root)
    print("diameter:", diameter)

226.翻转二叉树

题目描述

给你一棵二叉树的根节点 root ,翻转这棵二叉树,并返回其根节点。

示例 1:
输入:root = [4,2,7,1,3,6,9]
输出:[4,7,2,9,6,3,1]

题目链接

思路

  1. 递归法
    分析题目输入和输出发现,输出的左右子树的位置跟输入正好是相反的,于是我们可以递归的交换左右子树来实现。
    其实就是交换一下左右节点,然后再递归的交换左节点,右节点
    递归的两个条件如下:
    终止条件:当前节点为 null 时返回
    交换当前节点的左右节点,再递归的交换当前节点的左节点,递归的交换当前节点的右节点时间复杂度:每个元素都必须访问一次,所以是 O(n)
    空间复杂度:最坏的情况下,需要存放 O(h) 个函数调用(h是树的高度),所以是 O(h)
阅读全文 »

101.对称二叉树

题目描述

给你一个二叉树的根节点 root , 检查它是否轴对称。

题目链接

代码

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


class Solution(object):
    def isSymmetric(self, root):
        """
        递归法
        
        两个树互为镜像:
            它们的两个根结点具有相同的值
            每个树的右子树都与另一个树的左子树镜像对称
        :type root: TreeNode
        :rtype: bool
        """
        return self.check(root, root)
    
    def check(self, p, q):
        if not p and not q:
            return True
        if not p or not q:
            return False
        return p.val == q.val and self.check(p.left, q.right) and self.check(p.right, q.left)
    
    def isSymmetric1(self, root):
        """迭代法"""
        queue = list()
        queue.append(root)
        queue.append(root)
        while len(queue) != 0:
            t1 = queue.pop(0)
            t2 = queue.pop(0)
            if not t1 and not t2:
                continue
            if not t1 or not t2:
                return False
            if t1.val != t2.val:
                return False
            queue.append(t1.left)
            queue.append(t2.right)
            queue.append(t1.right)
            queue.append(t2.left)
        return True


if __name__ == "__main__":
    root = TreeNode(1)
    node2 = TreeNode(2)
    node3 = TreeNode(2)
    node4 = TreeNode(3)
    node5 = TreeNode(4)
    node6 = TreeNode(4)
    node7 = TreeNode(3)
    
    slt = Solution()
    # result = slt.isSymmetric(root)
    result = slt.isSymmetric(root)
    print(result)

53.最大子数组和

题目描述

给你一个整数数组 nums ,请你找出一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
子数组 是数组中的一个连续部分。

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

题目链接

代码

class Solution(object):
    def maxSubArray(self, nums):
        """
        动态规划
        
        用f(i)代表以第i个数结尾的连续子数组的最大和,那么我们的目标就是求
                            max{f(i)},0<=i<=n-1
        如何求 f(i) 呢?
        我们可以考虑 nums[i] 单独成为一段还是加入 f(i−1)对应的那一段,这取决于 nums[i] 和 f(i−1)+nums[i] 的大小,
        我们希望获得一个比较大的,于是可以写出这样的动态规划转移方程:
                            f(i)=max{f(i-1)+nums[i], nums[i]}
        :type nums: List[int]
        :rtype: int
        """
        # pre = 0
        # maxAns = nums[0]
        # for x in nums:
        #     pre = max(pre + x, x)
        #     maxAns = max(maxAns, pre)
        # return maxAns
        
        fi_array = [nums[0]]
        for i in range(1, len(nums)):
            fi_array.append(max(fi_array[i-1]+nums[i], nums[i]))
        return max(fi_array)
    
    def maxSubArray1(self, nums):
        """
        动态规划
        
        若前一个元素大于0,则将其加到当前元素上
        """
        for i in range(1, len(nums)):
            # 若前一个元素大于0,则将其加到当前元素上
            if nums[i - 1] > 0:
                nums[i] += nums[i-1]
        return max(nums)  # 返回修改过的数组中的最大值
    
    
    def maxSubArray2(self, nums):
        """
        贪心算法
        
        # 若当前指针所指元素之前的和小于0,则丢弃当前元素之前的数列
        """
        if not nums:  # 设置边界条件(列表为空)
            return -2147483648
        cur_sum = max_sum = nums[0]  # 当前和和最大和设置为列表第一个元素
        for i in range(1, len(nums)):
            # 若当前指针所指元素之前的和小于0,则丢弃当前元素之前的数列
            cur_sum = max(nums[i], cur_sum+nums[i])
            
            # 将当前和与最大和作比较,取最大
            max_sum = max(cur_sum, max_sum)
        
        return max_sum


if __name__ == "__main__":
    slt = Solution()
    nums = list([-2, 1, -3, 4, -1, 2, 1, -5, 4])
    res = slt.maxSubArray(nums)
    # res = slt.maxSubArray1(nums)
    print(res)

appium手机App自动化测试

手机App自动化测试环境搭建

  1. 安装appium client编程库
pip install appium-python-client
  1. 安装Appium Server
    下载链接链接:https://pan.baidu.com/s/19C9fGmoXne8DgfXhrTB2TQ
    提取码:kgwb
  2. 安装JDK
    下载链接同上。
    安装好之后,需要添加环境变量JAVA_HOME,例如:
JAVA_HOME   d:\tools\java\jdk1.8.0_211(jdk安装目录)
  1. 安装Android SDK
    下载链接同上。
    下载Android SDK文件包:androidsdk.zip,并解压。
    解压完成后添加环境变量ANDROID_HOME,例如:

阅读全文 »

pyhon+selenium测试WebTours网站登录注册功能

Web Tours下载、安装

WebTours下载、安装

安装selenium

在终端输入以下命令安装selenium:

pip install selenium

测试注册功能

user.txt

name1 1
name2 2
name3 3

注:本示例使用Firfox浏览器进行测试
代码:

from selenium import webdriver
from time import sleep

file = open("user.txt", "r")
for line in file:
    username = line.split()[0]
    password = line.split()[1]

    # 注册
    driver = webdriver.Firefox()
    driver.get("http://localhost:1080/webtours")
    driver.switch_to_default_content()
    driver.switch_to_frame("body")
    driver.switch_to_frame("info")
    # driver.find_element_by_link_text("sign up now").click()
    driver.find_element_by_partial_link_text("sign up").click()
    sleep(3)

    driver.switch_to_default_content()
    driver.switch_to_frame("body")
    driver.switch_to_frame("info")
    driver.find_element_by_name("username").send_keys(username)
    driver.find_element_by_name("password").send_keys(password)
    driver.find_element_by_name("passwordConfirm").send_keys(password)
    driver.find_element_by_name("register").click()
    sleep(3)

    driver.switch_to_default_content()
    driver.switch_to_frame("body")
    driver.switch_to_frame("info")
    expect = "Thank you, " + username
    actual = driver.find_element_by_tag_name("body").text
    if expect in actual:
        print("测试通过")
    else:
        print("测试失败")
driver.quit()

测试登录、订票功能

from selenium import webdriver
from time import sleep
from selenium.webdriver.support.select import Select

driver = webdriver.Firefox()
driver.get("http://localhost:1080/webtours")
sleep(3)
driver.switch_to_default_content()
driver.switch_to_frame("body")
driver.switch_to_frame("info")
actual = driver.find_element_by_tag_name("body").text
if "Welcome to the Web Tours site" in actual:
    print("打开网站成功")
else:
    print("打开网站失败")

driver.switch_to_default_content()
driver.switch_to_frame("body")
driver.switch_to_frame("navbar")
driver.find_element_by_name("username").send_keys("jojo")
driver.find_element_by_name("password").send_keys("bean")
driver.find_element_by_name("login").click()
sleep(3)

driver.switch_to_default_content()
driver.switch_to_frame("body")
driver.switch_to_frame("info")
actual = driver.find_element_by_tag_name("body").text
if "Welcome, jojo" in actual:
    print("登录成功")
else:
    print("登录失败")
sleep(3)

driver.switch_to_default_content()
driver.switch_to_frame("body")
driver.switch_to_frame("navbar")
driver.find_element_by_xpath("//img[@alt='Search Flights Button']").click()
sleep(3)

driver.switch_to_default_content()
driver.switch_to_frame("body")
driver.switch_to_frame("info")
Select(driver.find_element_by_name("depart")).select_by_visible_text("Denver")
Select(driver.find_element_by_name("arrive")).select_by_visible_text("London")
driver.find_element_by_name("findFlights").click()
sleep(3)

driver.switch_to_default_content()
driver.switch_to_frame("body")
driver.switch_to_frame("info")
driver.find_elements_by_name("outboundFlight")[1].click()
driver.find_element_by_name("reserveFlights").click()
sleep(1)

driver.switch_to_default_content()
driver.switch_to_frame("body")
driver.switch_to_frame("info")
driver.find_element_by_name("buyFlights").click()
sleep(1)

driver.switch_to_default_content()
driver.switch_to_frame("body")
driver.switch_to_frame("info")
actual = driver.find_element_by_tag_name("body").text
if "Thank you for booking through Web Tours." in actual:
    print("订票成功")
else:
    print("订票失败")
sleep(3)

driver.switch_to_default_content()
driver.switch_to_frame("body")
driver.switch_to_frame("info")
driver.find_element_by_name("Book Another").click()
sleep(1)

driver.switch_to_default_content()
driver.switch_to_frame("body")
driver.switch_to_frame("navbar")
driver.find_element_by_xpath("//img[@alt='SignOff Button']").click()

driver.switch_to_default_content()
driver.switch_to_frame("body")
driver.switch_to_frame("info")
actual = driver.find_element_by_tag_name("body").text
if "Welcome to the Web Tours site" in actual:
    print("注销成功")
else:
    print("注销失败")