附加题 63-65

面试题63：二叉搜索树的第k个结点

给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8）中，按结点数值大小顺序第三小结点的值为4。

题目梳理

取中序遍历结果的第k个元素即为所求。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def kthSmallest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        if not root or not k:
            return
        # 中序遍历结果即有序列表
        inord = []
        stack = []
        node = root
        while len(inord)<k and (stack or node):
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop()
            inord.append(node.val)
            node = node.right
        return inord[k-1]

面试题64：数据流中的中位数

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。

题目梳理

方法一：二分插入

添加数字的时候，插入到合适的位置。

class MedianFinder(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.nums = []

    def addNum(self, num):
        """
        :type num: int
        :rtype: None
        """
        # 使用二分查找的方式，找到合适的插入点，使nums是一个有序列表
        if self.nums == []:
            self.nums.append(num)
        else:
            start = 0
            end = len(self.nums)
            while start <= end:
                mid = (start+end)//2
                if num <= self.nums[mid]:
                    if mid>0 and num>self.nums[mid-1] or mid == 0:
                        self.nums.insert(mid,num)
                        break
                    else:
                        end = mid-1
                else:
                    if mid<len(self.nums)-1 and num<self.nums[mid+1] or mid == end-1:
                        self.nums.insert(mid+1,num)
                        break
                    else:
                        start = mid+1

    def findMedian(self):
        """
        :rtype: float
        """
        if self.nums == []:
            return
        length = len(self.nums)
        mid = length // 2
        # 数组长度为奇数
        if length & 0x1 == 1:
            return self.nums[mid]
        else:
            return (self.nums[mid - 1] + self.nums[mid]) / float(2)


# Your MedianFinder object will be instantiated and called as such:
# obj = MedianFinder()
# obj.addNum(num)
# param_2 = obj.findMedian()

方法二：使用最大、最小堆

• 将流中的数据分为相同数量的两部分，也就是两个堆，一个堆中的数据全都小于另外一个堆，
  • 小一点的堆里作为最大堆，大一点的堆作为最小堆，这样这两个堆顶元素就与所求的中位数相关。
• 当目前两堆总数为偶数的时候，把数字存入最大堆，然后重排最大堆，此时两堆数字总数为奇数
  • 如果最大堆的堆顶数字大于最小堆堆顶数字，则把两个堆顶数字交换，重排两堆，
  • 直接输出最大堆堆顶数字即为中位数；
• 如果当前两堆总数为奇数的时候，把数字存入最小堆，重排最小堆， 此时两堆数字总数为偶数
  • 如果最大堆的堆顶数字大于最小堆堆顶数字，则把两个堆顶数字交换，重排两堆，
  • 取两堆堆顶数字做平均即为中位数。

超出时间限制：

class MedianFinder(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.left = []
        self.right = []
        self.count = 0
    
    def max_heapify(self, nums, index):
        # 针对第i个数字进行最大堆调整
        left = 2*index+1
        right = 2*index+2
        # 找出三者中最大的元素索引
        if left < len(nums) and nums[index] < nums[left]:
            largest = left
        else:
            largest = index
        if right < len(nums) and nums[largest] < nums[right]:
            largest = right
            
        # 如果需要调整，则交换数组数值
        if index != largest:
            nums[largest], nums[index] = nums[index], nums[largest]
            # 递归调用本方法，进行堆最大化
            self.max_heapify(nums, largest)
         
    # 使以 i 为根的子树成为最小堆
    def min_heapify(self, nums, index):
        # 针对第i个数字进行最小堆调整
        left = 2*index+1
        right = 2*index+2
        length = len(nums)
        # 找出三者中最小的元素索引
        if left < length and nums[index] > nums[left]:
            smallest = left
        else:
            smallest = index
        if right < length and nums[smallest] > nums[right]:
            smallest = right
            
        # 如果需要调整，则交换数组数值
        if index != smallest:
            nums[smallest], nums[index] = nums[index], nums[smallest]
            # 递归调用本方法，进行堆最小化
            self.min_heapify(nums, smallest)
    
    def build_max_heap(self, nums):
        size = len(nums)
        # 输入异常情况
        if nums is None or size<=0:
            return 
        if size == 1:
            return nums
        for i in range(size-1, -1, -1):
            self.max_heapify(nums, i)
            
    def build_min_heap(self, nums):
        size = len(nums)
        # 输入异常情况
        if nums is None or size<=0:
            return 
        if size == 1:
            return nums
        for i in range(size-1, -1, -1):
            self.min_heapify(nums, i)
    
    def addNum(self, num):
        """
        :type num: int
        :rtype: None
        """
        # 保证两个堆的数据量尽可能相同
        # 数组长度为偶数
        if self.count & 0x1 == 0:
            self.left.append(num)
        else:
            self.right.append(num)
        self.count += 1

    def findMedian(self):
        """
        :rtype: float
        """
        # 定义数组长度
        if self.count == 1:
            return self.left[0]
        # 最大最小堆调整
        self.build_max_heap(self.left)
        self.build_min_heap(self.right)
        # 使left中保存的元素较小，按照最大堆的原理排序。堆顶大，底下的元素小。
        if self.left[0] > self.right[0]:
            self.left[0], self.right[0] = self.right[0], self.left[0]
        # 交换堆顶元素之后，继续调整，
        # 注意：此处只需要对堆顶元素开始的位置重新调整
        self.max_heapify(self.left, 0)
        self.min_heapify(self.right, 0)
        
        # 数组长度为奇数
        if self.count & 0x1 == 1:
            return self.left[0]
        else:
            return (self.left[0]+self.right[0])/2.0
        
# Your MedianFinder object will be instantiated and called as such:
# obj = MedianFinder()
# obj.addNum(num)
# param_2 = obj.findMedian()

• 使用大小堆来解决问题，其中大堆保存右半段较大的数字，小堆保存左半段较小的数组。
• 这样整个数组就被中间分为两段了，由于堆的保存方式是由大到小，我们希望大堆里面的数据是从小到大，这样取第一个来计算中位数方便。
• 小技巧，就是存到大堆里的数先取反再存，这样由大到小存下来的顺序就是实际上我们想要的从小到大的顺序。
• 当大堆和小堆中的数字一样多时，我们取出大堆小堆的首元素求平均值，当小堆元素多时，取小堆首元素为中位数。

面试题65：滑动窗口的最大值

给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

思路梳理

假设当前窗口起始位置为start,结束位置为end，我们要构造一个stack, 使得stack[0]为区间[start,end]的最大值。

• stack中保存的数据格式：（数字，索引值）
• 遍历数组的同时更新stack：
  • 首先将栈顶的、比当前元素小的数字对儿弹出；
  • 将当前元素压入栈顶；
  • 索引是否在窗口之外，将窗口外的栈底元素弹出；
  • 最后剩下的栈底元素即当前窗口的最大元素。

class Solution(object):
    def maxSlidingWindow(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        # 使用栈保存当前窗口中的最大值
        if not nums or not k:
            return
        stack = []
        ret = []
        for pos in range(len(nums)):
            # 将栈顶较小元素弹出
            while stack and stack[-1][0]<nums[pos]:
                stack.pop()
            stack.append((nums[pos], pos))
            # 如果是在窗口外的元素
            if pos >= k-1:
                # 将窗口外的元素弹出，最后剩下的栈底元素即当前窗口的最大元素
                while stack and stack[0][1] <= pos-k:
                    stack.pop(0)
                ret.append(stack[0][0])
        return ret