2022/4/11-2022/4/16

题目：538. Convert BST to Greater Tree

 

 

 

 

思路：

基本思想就是根据二叉搜索树的特性，一个节点比他大的点都一定在他的右边，可以先遍历书，取出所有的值，然后按照右-中-左的顺序遍历整个书，保证按照从大到小的顺序访问所有的节点，则每个节点应该加的值就是前面所访问过的节点的和。

代码：

def convertBST(self, root):

    def visit1(root):

        if root:

            visit1(root.left)

            vals.append(root.val)

            visit1(root.right)

    vals = []

    visit1(root)

    

    self.s = 0

    def visit2(root):

        if root:

            visit2(root.right)

            self.s += vals.pop()

            root.val = self.s

            visit2(root.left)

    visit2(root)

 

    return root

 

题目：34. Find First and Last Position of Element in Sorted Array

 

 

 

思路：

看到logn，基本上就是开始想二分，所以问题转化为二门求左边界和右边界，实际上就是再二分到目标值时边界缩小左边界还是右边界

代码：

    def searchRange(self, nums, target):

        def binarySearchLeft(A, x):

            left, right = 0, len(A) - 1

            while left <= right:

                mid = (left + right) // 2

                if x > A[mid]: left = mid + 1

                else: right = mid - 1

            return left

 

        def binarySearchRight(A, x):

            left, right = 0, len(A) - 1

            while left <= right:

                mid = (left + right) // 2

                if x >= A[mid]: left = mid + 1

                else: right = mid - 1

            return right

        

        left, right = binarySearchLeft(nums, target), binarySearchRight(nums, target)

        return (left, right) if left <= right else [-1, -1]

 

 

题目：669. Trim a Binary Search Tree

 

思路：

本题需要利用到二叉搜索树的特性，即节点左子树的点都小于这个点，右子树的点都大于这个节点。所以当节点小于范围左边界时，左子树都应该被舍弃，当节点大于范围右边界时，右子树都应该被舍弃。基于上述道理，利用递归原理即可完成下面的代码

代码：

      def trimBST(self, root, L, R):

        def trim(node):

            if node:

                if node.val > R:

                    return trim(node.left)

                elif node.val < L:

                    return trim(node.right)

                else:

                    node.left = trim(node.left)

                    node.right = trim(node.right)

                    return node

 

        return trim(root)

 

题目：24. Swap Nodes in Pairs

 

 

 

思路：

本题的重点在两两交换需要调整三个点，梳理好转换顺序就不难。最后的是为了处理只有一个元素的特殊情况

代码：

    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:

        if not head: return head

        prev, cur, ans = None, head, head.next

        while cur and cur.next:

            adj = cur.next

            if prev: prev.next = adj
 

            cur.next, adj.next = adj.next, cur

            prev, cur = cur, cur.next


        return ans or head