python 题目

1. 求输出
    

   f0,f1,f2 = [lambda x:x*i for i in range(3)]
   print(f0(1),f1(2),f2(3))
   #2 4 6

   这个原理很简单，其实就是f0 = f1 = f2 = x * 2，循环中i的根本不会输出
    
2. leetcode上有个题目要求获得所有子域名，比如mail.126.com，子域名：com，126.com，mail.126.com
   思路是利用split和pop，split除了切割符以外，还可以输入一个参数来规定只对前几个切割符号分片，利用split获得子域名后，pop出来即可

   a = "google.mail.com"
   for i in range(len(a.split('.'))):
       print(a.split('.',i).pop())
   
   #google.mail.com
   #mail.com
   #com

3. leetcode题目，根据输入的层数，输出杨辉三角：
         1
       1  1
     1  2  1
   1  3  3  1
   最简单的方法是从第三层循环每层中间的元素

   output = [[1] * i for i in range(1,numRows+1)]
   if numRows <= 2:
       print(output)
   else:
       for i in range(2,numRows):
           for j in range(1,i):
               output[i][j] = output[i-1][j-1] + output[i-1][j]
       print(output)

   有一个很巧妙的方法利用两层构一个差值：
   [0 1 2 1] + [1 2 1 0] = [1 3 3 1]

   l = [1]
   output = []
   i = 0
   while i < numRows:
       output.append(l)
       l = [sum(t) for t in zip([0]+l, l+[0])]
       i += 1
   print(output)

4. 异或算符：
   相同为零，不同为一  1^1=0  0^0=0  1^0=1 0^1=1
   通过异或可以不用额外空间交换两个数：

   a = 10
   b = 20
   a=a^b
   b=b^a
   a=a^b
   print(a,b)
   # 20 10

   给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素：

   nums = [[4,1,2,1,2]]
   res = 0
   for num in nums:
       res = res^num
   print(res)
   #4

5. 判断一个无向图是否是树：
   一棵树要求无向图中不能有孤立节点和环路，那么前提要求是节点数n应该等于egde数量+1。 再考虑是否有孤立节点，即遍历一遍是否能遍历到所有的节点。（满足前提要求，如果没有孤立节点，则不可能存在环路，反之如果有环路，则一定有孤立节点）

   def istree(n,a):
       
       #树的边长一定比节点少一个，否则就是孤立或者有环路
       if len(a) != n-1:
           return False
       
       nodes = []  #储存历史节点
       current_layer = [1]  #储存当前层节点
       iterate = 0 #防止死循环
       
       while(len(nodes) < n and iterate < n):
           print('=======================')
           print('nodes:',nodes,'current_layer',current_layer)
           iterate += 1
           next_layer = [] #储存下一层节点的临时空间
           
           #对当前层所有节点寻找所有下一层节点
           while(current_layer):
               node = current_layer.pop()
               for i in range(len(a)):
                   if node in a[i]:
                       
                       if a[i].index(node) == 1:
                           tmp = 0
                       else:
                           tmp = 1
                       if a[i][tmp] not in nodes+current_layer:
                           next_layer.append(a[i][tmp])
               nodes.append(node)
           print('next_layer:',next_layer)
           #更新当前层节点
           current_layer = next_layer
           #如果无下一层节点表示遍历结束
           if next_layer == []:
               break
       
       #历史节点应该包括所有节点，否则就有孤立节点存在
       if len(nodes) == n:
           return True
       else:
           return False
   
   istree(4,[[1,2],[2,3],[1,4]])
   #=======================
   #nodes: [] current_layer [1]
   #next_layer: [2, 4]
   #=======================
   #nodes: [1] current_layer [2, 4]
   #next_layer: [3]
   #=======================
   #nodes: [1, 4, 2] current_layer [3]
   #next_layer: []
   #Out[1]: True

6. 输出一颗二叉树的所有路径：
   用递归的方法，根据叶节点的左右子节点均为空的性质

   class Solution(object):
       def binaryTreePaths(self, root):
           """
           :type root: TreeNode
           :rtype: List[str]
           """
           path = ''
           res = []
           self.TreePathsHelper(root, path, res)
           return res
       def TreePathsHelper(self,root, path, res): 
           if root is None: 
               return res
           path += str(root.val) 
           if root.left is not None: 
               self.TreePathsHelper(root.left, path + '->', res) 
           if root.right is not None: 
               self.TreePathsHelper(root.right, path + '->', res) 
           if root.left is None and root.right is None: 
               res.append(path) 

   
    
7. 二叉树层次遍历
            1
        2      3
      4  5      6
   输出[[4,5,6],[2,3],[1]]
   初始想法储存下当前层，再找下一层节点：

   def levelOrderBottom(self, root):
           if root == None:
               return []
           nodes = []
           next_layer = [1]
           current_layer = [root]
           while(next_layer):
               next_layer = []
               tmp = []
               while(current_layer):
                   node = current_layer.pop()
                   tmp.append(node.val)
                   if node.left != None:
                       next_layer.append(node.left)
                   if node.right != None:
                       next_layer.append(node.right)
               if tmp != []:
                   nodes.append(tmp)
               current_layer = next_layer[::-1]
           nodes = nodes[::-1]
           return nodes

   改进，用len(current_layer)就可以只丢出当前层节点，每次pop第一个元素出去：

   def levelOrderBottom(self, root):
           """
           :type root: TreeNode
           :rtype: List[List[int]]
           """
           if not root:
               return []
           s = [root]
           res = []
           while(s):
               l = []
               for i in range(len(s)):
                   node = s.pop(0)
                   if node.left != None:
                       s.append(node.left)
                   if node.right != None:
                       s.append(node.right)
                   l.append(node.val)
               res.append(l)
           return res[::-1]

8.