code day day up

1、快排

def quick_sort(lists, i, j):
    if i >= j:
        return lists
    pivot = lists[i]
    low = i
    high = j
    while i < j:
        while i < j and lists[j] >= pivot:
            j -= 1
        lists[i] = lists[j]
        while i < j and lists[i] <= pivot:
            i += 1
        lists[j] = lists[i]
    lists[j] = pivot
    quick_sort(lists, low, i - 1)
    quick_sort(lists, i + 1, high)

    return lists

2、两数之和

def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        d_map = {}
        for i, num in enumerate(nums):
            if target - num in d_map:
                return [d_map[target - num], i]
            d_map[num] = i
        return []

3、有效括号数

def isValid(self, s):
        if len(s) % 2 == 1:
            return False
        pairs = {
            ")": "(",
            "]": "[",
            "}": "{",
        }
        stack = []
        for ch in s:
            # 如果查询到了右边，就把当前类型的左边括号pop掉，清空，继续下一个类型
            if ch in pairs:
                if not stack or stack[-1] != pairs[ch]:
                    return False
                stack.pop()
            else:
                stack.append(ch)

        return not stack

4、合并两个有序链表

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def mergeTwoLists(self, l1, l2):
        prehead = ListNode(-1)
        prev = prehead

        while l1 and l2:
            if l1.val <= l2.val:
                prev.next = l1
                l1 = l1.next
            else:
                prev.next = l2
                l2 = l2.next
            prev = prev.next

        # 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev.next = l1 if l1 is not None else l2

        return prehead.next

5、爬楼梯

class Solution(object):
    def climbStairs(self, n):
        climb = {}
        
        climb[0] = 0
        climb[1] = 1
        climb[2] = 2
        
        for i in range(3,n+1):
            climb[i] = climb[i-1] + climb[i-2]
        return climb[n]

6、二叉数中序遍历

# 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 inorderTraversal(self, root):
        inorderList = []
        def Dfs(root):
            if not root:
                return
            Dfs(root.left)
            inorderList.append(root.val)
            Dfs(root.right)
            return

        Dfs(root)
        return inorderList

7、对称二叉数

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSymmetric(self, root):
        if not root:
            return False
        return self.isSymmetrics(root.left,root.right)

    def isSymmetrics(self, left, right):
        if left and right and left.val==right.val:
            if self.isSymmetrics(left.right,right.left) and self.isSymmetrics(left.left,right.right):
                return True
        if not left and not right:
            return True
        return False

8、二叉数最大深度

def maxDepth(self, root):
        if root is None: 
            return 0 
        else: 
            left_height = self.maxDepth(root.left) 
            right_height = self.maxDepth(root.right) 
            return max(left_height, right_height) + 1 

9、买股票的最佳时机

def maxProfit(self, prices):
        inf = int(1e9)
        minprice = inf
        maxprofit = 0
        for price in prices:
            maxprofit = max(price - minprice, maxprofit)
            minprice = min(price, minprice)
        return maxprofit

10、只出现一次的数字

def singleNumber(self, nums: List[int]) -> int:
        x = 0
        for num in nums:
            x ^= num
        return x

、电话号码的组合

 def letterCombinations(self, digits):
        """
        :type digits: str
        :rtype: List[str]
        """
        dic = {"2": ["a", "b", "c"],
                "3": ["d", "e", "f"],
                "4": ["g", "h", "i"],
                "5": ["j", "k", "l"],
                "6": ["m", "n", "o"],
                "7": ["p", "q", "r", "s"],
                "8": ["t", "u", "v"],
                "9": ["w", "x", "y", "z"]}
        res = []
        def backtrack(comb, digits_num):
            if len(digits_num) == 0:
                res.append(comb)
            else:
                for i in dic[digits_num[0]]:
                    backtrack(comb + i, digits_num[1:])

        if digits:
            backtrack("", digits)
        return res

3、删除连表中倒数第n个数

def getLength(head):
    length = 0
    while head:
        length += 1
        head = head.next
    return length

    dummy = ListNode(0, head)
    length = getLength(head)
    cur = dummy
    for i in range(1, length - n + 1):
        cur = cur.next
    cur.next = cur.next.next
    return dummy.next

三个数相加

def threeSum(self, nums):
    """
    :type nums: List[int]
    :rtype: List[List[int]]
    """
    nums.sort()
    print(nums)
    count = len(nums)
    collect = []
    for i in range(count):
        left = i + 1
        right = count - 1
        # 避免重复找同一个数据
        if i > 0 and nums[i] == nums[i - 1]:
            left += 1
            continue
        # 数据按小到大排列，每次选取nums[i]，在其后寻找符合a + b + c = 0的两个数据
        while left < right:
            sum = nums[i] + nums[left] + nums[right]
            if sum == 0:
                col = [nums[i], nums[left], nums[right]]
                collect.append(col)
                left += 1
                right -= 1

                while nums[left] == nums[left - 1] and left < right:
                    left += 1
                while nums[right] == nums[right + 1] and left < right:
                    right -= 1
            if sum < 0:
                left += 1
            elif sum > 0:
                right -= 1

    return collect