Given binary tree [3,9,20,null,null,15,7],
    3
   / 
  9  20
    /  
   15   7
return its bottom-up level order traversal as:
[
  [15,7],
  [9,20],
  [3]
]

class Solution:
    def levelOrderBottom(self, root):
        """
        返回节点值的自底向上的顺序遍历。（从左到右，从叶到根逐级地）
        :param root: TreeNode
        :return: list[list[int]]
        """
        stack = [(root, 0)]
        res = []
        # 如果栈不为空
        while stack:
            # 将栈中最后一个元素弹出
            node, level = stack.pop()
            # 如果该结点存在
            if node:
                # 如果结果列表的长度小于层数+1
                if len(res) < level + 1:
                    res.insert(0, [])
                # 将当前结点的值添加在结果列表中
                res[-(level + 1)].append(node.val)
                stack.append((node.right, level + 1))
                stack.append((node.left, level + 1))
        return res

class Solution:
    def sortedArrayToBST(self, num):
        """
        将已排序的数组转换为高度平衡二叉树
        :param num: list[int]
        :return: TreeNode
        """
        # 如果列表为空
        if not num:
            return None
        # 列表中间的值为列表长度整数2
        mid = len(num) // 2
        # 生成一个以中值为结点的值的作为根结点
        root = TreeNode(num[mid])
        # 递归求出
        # 左子树为小于中间值一部分
        root.left = self.sortedArrayToBST(num[:mid])
        # 右子树为大于中间值的一部分
        root.right = self.sortedArrayToBST(num[mid + 1:])
        return root

class Solution:
    def isBalanced(self, root):
        """
        判断一个树是否为平衡二叉树
        当check函数的发挥值不等于-1时返回true，等于-1是返回false
        :param root: TreeNode
        :return: bool
        """
        return self.check(root) != -1

    def check(self, root):
        """
        检查结点
        :param root: TreeNode
        :return: int
        """
        # 结点为空时
        if root is None:
            return 0
        # 递归得出左子树的返回值
        left = self.check(root.left)
        # 递归得出右子树的返回值
        right = self.check(root.right)
        # 如果左子树不为平衡树或者右子树不为平衡二叉树，
        # 左右子树想减的值大于1(-1-(-1))左右子树不为平衡树的情况
        if left == -1 or right == -1 or abs(left - right) > 1:
            return -1
        # left right分别等于0或1的情况
        return 1 + max(left, right)

class Solution:
    def minDepth(self, root):
        # 如果是空树
        if not root:
            return 0
        # 递归求出子节点的深度
        left = self.minDepth(root.left)
        right = self.minDepth(root.right)
        # 如果节点为空
        if left == 0 or right == 0:
            return left + right + 1
        # 不为空情况下计算左右子树的最小深度
        return min(left, right) + 1

For example:
Given the below binary tree and sum = 22,
              5
             / 
            4   8
           /   / 
          11  13  4
         /        
        7    2      1
return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.

class Solution:
    def hasPathSum(self, root, sum):
        """
        判断从根到叶子节点的值之和是否有等于sum的
        :param root: TreeNode
        :param sum: int
        :return: bool
        """
        # 如果是空树
        if not root:
            return False
        # 如果只有根节点，并且根节点的值等于sum
        if root.val == sum and not root.left and not root.right:
            return True
        # 递归判断对左右节点的情况，每次需要将sum减去节点的值
        return self.hasPathSum(root.left, sum - root.val) 
               or self.hasPathSum(root.right, sum - root.val)

For example, given numRows = 5,
Return

[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]

import copy


class Solution:
    def generate(self, numRows):
        # 最外侧的列表
        allrows = []
        # 每一行的列表
        row = []
        # 循环迭代每一行
        for i in range(numRows):
            # 像每行的第一个元素插入1
            row.insert(0, 1)
            # 对该行进行迭代(1开始因为已经插入了1，该行的长度-1因为保留了上一行的参数)
            for j in range(1, len(row) - 1):
                # 其中的参数等于索引为j和j+1位置的和
                row[j] = row[j] + row[j + 1]
            # 进行深拷贝，如果不进行深拷贝，Python会一直操作的是一个row最后只会append一个相同的row
            allrows.append(copy.deepcopy(row))
        return allrows

For example, given k = 3,
Return [1,3,3,1].

class Solution:
    def getRow(self, rowIndex):
        """
        计算帕斯卡三角形的制定行数的元素
        :param rowIndex: int
        :return: list
        """
        row = [1]
        for i in range(rowIndex):
            # 使用列表推导式迭代x+y的值
            # 其中x和y分别等于[0] + row和row + [0]的第一列和第二列
            row = [x + y for x, y in zip([0] + row, row + [0])]
        return row

"A man, a plan, a canal: Panama" is a palindrome.
"race a car" is not a palindrome.

class Solution:
    def isPalindrome(self, s):
        """
        判断字符串是否是回文(只考虑字母和数字)
        :param s: str
        :return: bool
        """
        # 分别得到第一个和最后一个字符的索引
        i, r = 0, len(s) - 1
        # 判断回文只需要判断一半
        while i < r:
            # 当左边字符索引小鱼右边字符串并且
            # 左字符串属于字母和数字时
            while i < r and not s[i].isalnum():
                i += 1
            # 当左边字符索引小鱼右边字符串并且
            # 右字符串属于字母和数字时
            while i < r and not s[r].isalnum():
                r -= 1
            # 为了判断相等，均转换为小写去判断是否相等
            if s[i].lower() != s[r].lower():
                return False
            # 左字符向后移动一个
            i += 1
            # 右字符向前移动
            r -= 1
        return True

class Solution:
    def singleNumber(self, nums):
        """
        找到数组只只出现了一次的元素(其他元素都出现了两次)
        :param nums: list[int]
        :return: int
        """
        # 使用set()去重把每个元素都得到一个
        # 求出所有单个元素的和,求出两倍的值
        # 再减去未去重时所有元素的和
        return 2 * sum(set(nums)) - sum(nums)

class Solution:
    def hasCycle(self, head):
        """
        判断单链表中是否有环(不使用额外的空间)
        :param head: ListNode
        :return: bool
        """
        # 如果链表的头节点或者头节点的下一个节点为空
        if not head or not head.next:
            return False
        # 使用快慢指针
        # 慢指针一次向前移动一个节点
        slow = head
        # 快指针一次向前移动两个节点
        fast = head.next
        # 如果快指针存在并且快指针的下一个节点也存在
        while fast and fast.next:
            # 使慢指针向后移动一个节点
            slow = slow.next
            # 使快指针向后移动两个节点
            fast = fast.next.next
            # 如果快指针等于慢指针，即有环
            if slow == fast:
                return True
        return False

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> Returns -3.
minStack.pop();
minStack.top();      --> Returns 0.
minStack.getMin();   --> Returns -2.

class MinStack:
    def __init__(self):
        self.q = []

    def push(self, x):
        """
        向栈种推入一个元素
        :param x: int
        :return: void
        """
        curMin = self.getMin()
        if curMin is None or x < curMin:
            curMin = x
        self.q.append((x, curMin))

    def pop(self):
        """
        弹出一个元素
        :return: void
        """
        self.q.pop()

    def top(self):
        """
        得到栈顶元素
        :return: int
        """
        if len(self.q) == 0:
            return None
        else:
            return self.q[len(self.q) - 1][0]

    def getMin(self):
        """
        得到最小栈中最小的元素
        :return: int
        """
        if len(self.q) == 0:
            return None
        else:
            return self.q[len(self.q) - 1][1]

For example, the following two linked lists:

A:          a1 → a2
                   ↘
                     c1 → c2 → c3
                   ↗            
B:     b1 → b2 → b3
begin to intersect at node c1.

class Solution:
    def getIntersectionNode(self, headA, headB):
        """
        求出两个单链表的交点
        :param headA: ListNode
        :param headB: ListNode
        :return: ListNode
        """
        if not headA or not headB:
            return None
        pa = headA
        pb = headB
        # 如果pa节点不等于pb节点
        while pa is not pb:
            # Python中的三元表达式格式为:为真时的结果 if 判定条件 else 为假时的结果
            pa = headB if not pa else pa.next
            pb = headA if not pb else pb.next
        return pa

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

class Solution:
    def twoSum(self, numbers, target):
        """
        计算整形列表中是否有两个值的和与目标值相等
        :param numbers: list[int]
        :param target: int
        :return: list[int]
        """
        # 使用一个字典存储已经遍历过的元素
        dic = {}
        # 循环遍历
        for i in range(len(numbers)):
            # 如果目标值减去遍历的元素的值在字典中
            if target - numbers[i] in dic:
                # 即返回保存在字典中元素的下标
                # 并且要求索引从1开始 所以需要+1
                return [dic[target - numbers[i]] + 1, i + 1]
            # 将遍历过的值和下标存入字典中
            dic[numbers[i]] = i

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

class Solution:
    def twoSum(self, numbers, target):
        """
        计算整形列表中是否有两个值的和与目标值相等
        :param numbers: list[int]
        :param target: int
        :return: list[int]
        """
        # 使用一个字典存储已经遍历过的元素
        dic = {}
        # 循环遍历
        for i in range(len(numbers)):
            # 如果目标值减去遍历的元素的值在字典中
            if target - numbers[i] in dic:
                # 即返回保存在字典中元素的下标
                # 并且要求索引从1开始 所以需要+1
                return [dic[target - numbers[i]] + 1, i + 1]
            # 将遍历过的值和下标存入字典中
            dic[numbers[i]] = i

1 -> A
2 -> B
3 -> C
...
26 -> Z
27 -> AA
28 -> AB

class Solution:
    def convertToTitle(self, n):
        """
        将数字转换为excel的列名
        :param n: int
        :return: str
        """
        # 存放结果的字符串
        res = ''
        # n不为0时进入循环
        while n != 0:
            # 求余得到一个字符
            ch = chr((n - 1) % 26 + 65)
            # 除以26求模
            n = (n - 1) // 26
            res = ch + res
        return res