Python剑指offer打卡-6

Python剑指offer打卡-6

文章目录

  • Python剑指offer打卡-6
    • 二叉树中和为某一值的路径
    • 判断是否是二叉搜索树的后序遍历序列结果
    • 从上往下打印二叉树
    • 最小的k个数
    • 数据流中的中位数
    • 参考

二叉树中和为某一值的路径

  • 问题描述

    问题描述:
    输入一颗二叉树的根节点和一个整数,打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树
    的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中,数组长度大的数
    组靠前).
    
    解决方案:
    递归
    
    注意:
    路径表示为根结点到叶子结点的全路径
    
  • 代码(解题思路)

    class Solution:
    
        def FindPath(self, root, expectNumber):
    
            if root is None:
                return []
    
            res = []
            if root.val == expectNumber and root.left is None and root.right is None:
                res.append(root.val)
    
            left = self.FindPath(root.left, expectNumber - root.val)
            right = self.FindPath(root.right, expectNumber - root.val)
            for path in left + right:
                # 向上添加路径
                res.append([root.val] + path)
    
            return res
    

判断是否是二叉搜索树的后序遍历序列结果

  • 问题描述

    问题描述:
    输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,
    否则输出No。假设输入的数组的任意两个数字都互不相同。
    
    解决方案:
    BST:整体上应该保证结点数值右大左小
    递归
    
    注意:
    即:空列表也空树的结果
    if []: return True
    
  • 代码

    图解

    Python剑指offer打卡-6_第1张图片

    class Solution:
        def VerifySquenceOfBST(self, sequence):
            # write code here
            if not sequence:
                return False
            
            def isTree(sequence):
                """判断是否为搜索树"""
                
                root = sequence[-1]
                length = len(sequence)
                # 左小右大原则
                # 左子树
                for i in range(length):
                    if sequence[i] > root:
                        break
                left = True
                # 右子树
                for j in range(i, length - 1):
                    if sequence[j] < root:
                        return False
                right = True
                # 递归遍历
                if i > 0:
                    left = isTree(sequence[:i])
                if i < length - 1:
                    right = isTree(sequence[i: length - 1])
                
                return left and right
            
            return isTree(sequence)
    

从上往下打印二叉树

  • 问题描述

    问题描述:
    从上往下打印出二叉树的每个节点,同层节点从左至右打印
    
    解决方案:
    简单的层序遍历
    
  • 代码

    图解

    Python剑指offer打卡-6_第2张图片

    class Solution:
            def levelOrder(self, root: TreeNode) -> List[int]:
                """"层序遍历"""
                
                    if not root: return []
                    
                    res, queue = [], collections.deque()
                    queue.append(root)
                    
                    while queue:
                            node = queue.popleft()
                            res.append(node.val)
                            if node.left: queue.append(node.left)
                            if node.right: queue.append(node.right)
                                
           	        return res
        
    	def levelOrder(self, root):
    		"""层序遍历(每一层遍历)"""
            
    		if root is None: return []
    		res, deque = [], collections.deque()
    		deque.append(root)
    		
    		while deque:
    			tmp = []
    			for _ in range(len(deque)):
    				node = deque.popleft()
    				tmp.append(node.val)
    				if node.left: deque.append(node.left)
    				if node.right: deque.append(node.right)
    			res.append(tmp)
    
    		rerurn res
    	
                def levelOrder(self, root: TreeNode) -> List[List[int]]:
                	"""Z字形遍历"""
                    
                    if not root: return []
                    res, deque = [], collections.deque([root])
    
                    while deque:
                        tmp = collections.deque()
                        for _ in range(len(deque)):
                            node = deque.popleft() # 从左向右遍历
                            if len(res) % 2: tmp.appendleft(node.val) # 偶数层,队列首部
                            else: tmp.append(node.val) # 奇数层,队列尾部
                            if node.left: deque.append(node.left)
                            if node.right: deque.append(node.right)
    
                        res.append(list(tmp))
                    return res
    

最小的k个数

  • 问题描述

    问题描述:
    输入整数数组 arr ,找出其中最小的 k 个数。例如,输入4、5、1、6、2、7、3、8这8个数字,
    则最小的4个数字是1、2、3、4。
    
  • 代码(解题思路)

    图解最大堆

    Python剑指offer打卡-6_第3张图片

    import heapq  # 默认构建最小堆,即父节点的值大于其任意子节点的值
    
    
    class Solution:
    
        def getLeastNumbersfForHeap(self, arr, k):
            """"获取最小k个数字"""
    
            if k == 0:
                return list()
    
            # 构建最大堆
            hp = [-x for x in arr[:k]]
            heapq.heapify(hp)
    
            for i in range(k, len(arr)):
                if hp[0] <= -arr[i]:
                    heapq.heappop(hp)
                    heapq.heappush(hp, -arr[i])
            res = [-x for x in hp]
    
            return res
    
        def getLeastNumbersForSort(self, numbs, k):
    
            def quickSort(nums, start, end):
                """"快速排序法"""
    
                if start >= end:
                    return list()
    
                low = start
                high = end
                mid = nums[start]
    
                while low < high:
                    while low < high and nums[high] >= mid:
                        high -= 1
                    nums[low] = nums[high]
                    while low < high and nums[low] < mid:
                        low += 1
                    nums[high] = nums[low]
                # 交换基准
                nums[low] = mid
                quickSort(nums, start, low - 1)
                quickSort(nums, low + 1, end)
            quickSort(numbs, 0, len(numbs) - 1)
    
            return numbs[:k]
    

数据流中的中位数

  • 问题描述

    问题描述:
    中位数是有序列表中间的数。如果列表长度是偶数,中位数则是中间两个数的平均值。
    
    例如:
    [2,3,4] 的中位数是 3
    [2,3] 的中位数是 (2 + 3) / 2 = 2.5
    
  • 代码(解题思路)

    import heapq
    
    
    class Solution:
    
        def __init__(self):
            """初始化最大最小堆"""
    
            self.max_heap = []
            self.min_heap = []
    
        def addNum(self, num: int) -> None:
            """添加元素"""
    
            # 相等保证最小堆个数大于等于最大堆(最大相差一个)
            # 最大堆->最小堆  —>最大堆
            if len(self.max_heap) == len(self.min_heap):
                heapq.heappush(self.min_heap, -heapq.heappushpop(self.max_heap, -num))
            else:
                heapq.heappush(self.max_heap, -heapq.heappushpop(self.min_heap, num))
    
        def findMedian(self) -> float:
            if len(self.min_heap) == len(self.max_heap):
                return (-self.max_heap[0] + self.min_heap[0]) / 2
            else:
                return self.min_heap[0]
    

参考

最大最小堆整理 & heapq最小最大堆

数据结构与算法(4)——优先队列和堆

你可能感兴趣的:(#,剑指offer,队列,算法,数据结构,二叉树,python)