20/3月

1. 树

1. 1树的前中后层序

class Solution(object):
	# 前序
    def preorderTraversal(self, root):
        if not root:return []
        val = []
        nodes = [root]
        
        while nodes:
            cur = nodes.pop()
            val.append(cur.val)
            if cur.right:nodes.append(cur.right)
            if cur.left :nodes.append(cur.left)
        return val

	# 中序
    def inorderTraversal(self, root):
        nodes, val = [], []
        
        while root or nodes:
            while root:
                nodes.append(root)
                root = root.left
            root = nodes.pop()
            val.append(root.val)
            root = root.right
        return val

	# 后序
    def postorderTraversal(self, root):
        if not root:return []
        val = []
        nodes = [root]
        
        while nodes:
            cur = nodes.pop()
            val.append(cur.val)
            if cur.left:nodes.append(cur.left)
            if cur.right:nodes.append(cur.right)
        return val[::-1]

	# 层序
    def levelOrder(self, root):
        if not root:return []
        nodes = [root]
        val = []
        
        while nodes:
            l = len(nodes)
            val.append([n.val for n in nodes])
            for i in range(l):
                if nodes[i].left:nodes.append(nodes[i].left)
                if nodes[i].right:nodes.append(nodes[i].right)
            nodes = nodes[l:]
        return val

1.2 树的深度

class Solution(object):
    def maxDepth(self, root):
        if not root:return 0
        left = self.maxDepth(root.left)
        right= self.maxDepth(root.right)
        return max(left, right) + 1

1.3 树的重建

• POST + IN

class Solution(object):
    def build(self, inorder, postorder):
        if not inorder: return

        root = TreeNode(postorder[-1])
        index = inorder.index(postorder[-1])
        root.left = self.build(inorder[:index], postorder[:index])
        root.right= self.build(inorder[index+1:], postorder[index:-1])
        
        return root
        
    def buildTree(self, inorder, postorder):
        
        return self.build(inorder, postorder)

• PRE + IN

class Solution(object):
    def build(self,preorder, inorder):
        if not inorder:return 

        root = TreeNode(preorder[0])
        index = inorder.index(preorder[0])
        
        root.left  = self.build(preorder[1:index+1], inorder[:index])
        root.right = self.build(preorder[index+1:], inorder[index+1:])
        
        return root
    def buildTree(self, preorder, inorder):
        return self.build(preorder, inorder)

2. 小顶堆

import heapq

q = []
k = 1
# 小顶堆
heapq.heappush(q,k)
heapq.heappop(q)

# 大顶堆
heapq.heappush(q,-k)
-heapq.heappop(q)

4.排序

# 冒泡
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)):
            for j in range(i):
                if nums[i] < nums[j]:
                    nums[i], nums[j] = nums[j], nums[i]
        return nums

# 快速排序
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        def helper(nums):
            if len(nums) < 2:
                return nums
            key = nums[0]
            left = [i for i in nums[1:] if i <= key]
            right = [i for i in nums[1:] if i > key]
            return helper(left) + [key] + helper(right)
        return helper(nums)

# 插入排序
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        for i in range(1, len(nums)):
            for j in range(i, 0, -1):
                if nums[j-1] > nums[j]:
                    nums[j-1], nums[j] = nums[j], nums[j-1]
                else:
                    break
        return nums

5. 字典树

class Trie(object):

    def __init__(self):
        self.root = {}

    def insert(self, word):
        node = self.root
        for s in word:
            if s not in node:
                node[s] = {}

            node = node[s]
        node["is_word"] = True

    def search(self, word):
        node = self.root
        for s in word:
            if s in node:
                node = node[s]
            else:
                return False
        return "is_word" in node and node["is_word"]

    def startsWith(self, prefix):
        node = self.root
        for s in prefix:
            if s in node:
                node = node[s]
            else:
                return False
        return True

插入操作

root = {}
words = ["apple","app"]

for word in words:
    node = root
    for s in word:
        if s not in node:
            node[s] = {}
        node = node[s]
    node["is_word"] = True

6. Tips

# 判断是否为数字
char.isdigit()

# 排序 时间复杂度 nlogn
nums.sort()

# 字符串操作
s = "abccccdd"
set(s)
s.count('a')

all

# 1385
        for a in arr1:
            if all(abs(a-b) > d for b in arr2):
                res += 1
        return res

set 用discard ,list用 remove
逆序排序

words.sort(key=lambda word: word[::-1])

Mac 查看dir

ls

Python 文件运行

def parse_args():
    debug = False
    if len(sys.argv) == 2:
        if sys.argv[1] == 'debug':
            print("test mode")
            debug = True
        else:
            print_help_and_exit()
    return debug

% python3 MAin.py 1 就走else，两个参数（打印[‘MAin.py’, ‘1’]）
% python3 MAin.py debug 就走print，“test mode”

• 数组新建法

        # res = [i for i in range(n)]
        # idx = 0
            
        res,idx = list(range(n)), 0

• remove() 慢于 pop()

a.remove(a[i]) # remove慢于pop
a.pop(i) # pop传入idx
# 等于：
del a[i]

• 对二维数组遍历

for row in grid:
	if 1 in row: 
		return -1

而不是

for row in grid:
	for num in row:
		if num == 1:
			return 1

开根号

import math
math.aqrt(x)

x**0.5