interview_binarysearch

1.search range

 

class Solution(object):
    def searchRange(self, nums, target):
        res=[-1,-1]
        if(len(nums)==0):
            return res
        
        left,right=0,len(nums)-1
        while(left+1<right):
            mid=left+(right-left)//2
　　　　　　　　  #mid=left+((right-left)>>1)
            if(nums[mid]==target):
                right=mid
            elif(nums[mid]<target):
                left=mid+1
            else:
                right=mid-1
        if(nums[left]==target):
            res[0]=left
        elif(nums[right]==target):
            res[0]=right


        left,right=0,len(nums)-1
        while(left+1<right):
            mid=left+(right-left)//2

            if(nums[mid]==target):
                left=mid
            elif(nums[mid]<target):
                left=mid+1
            else:
                right=mid-1
        if(nums[right]==target):
            res[1]=right
        elif(nums[left]==target):
            res[1]=left

        return res

2.search in a rotated array(may have duplicated elements)

class Solution:
    def searchInRotate(self,nums,target):
        if(len(nums)==0):
            return -1

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

        while(left+1<right):
            mid=left+(right-left)//2
            if(nums[mid]==target):
                return mid

            if(nums[mid]<nums[right]):
                if(nums[mid]<=target<=nums[right]):
                    left=mid
                else:
                    right=mid
            elif(nums[mid]>nums[right]):
                if(nums[left]<=target<=nums[mid]):
                    right=mid
                else:
                    left=mid
            else:
                right-=1

        if(nums[left]==target):
            return left
        if(nums[right]==target):
            return right
        return -1

nums1=[9,12,15,20,1,3,6,7]
print(Solution().searchInRotate(nums1,15))
print(Solution().searchInRotate(nums1,5))



nums1=[9,12,15,20,1,1,1,3,6,7]
print(Solution().searchInRotate(nums1,15))
print(Solution().searchInRotate(nums1,1))

3. basic op of BST

#coding:utf-8

class TreeNode:
    def __init__(self,x):
        self.val=x
        self.left=None
        self.right=None
    
class Solution:
    def BST_insert(self,root,node):
        '''
        将node节点插入以root为根的BST中
        '''
        if(node.val<=root.val):
            if(root.left):
                self.BST_insert(root.left,node)
            else:
                root.left=node
        else:
            if(root.right):
                self.BST_insert(root.right,node)
            else:
                root.right=node

    def BST_search(self,root,val):
        if(root.val==val):
            return True

        if(root.val>val):
            if(root.left):
                return self.BST_search(root.left,val)
            else:
                return False
        else:
            if(root.right):
                return self.BST_search(root.right,val)
            else:
                return False

    def bfs(self,root):
        res=[]
        if(root==None):
            return res
        
        que=[]
        que.append((root,[root.val]))
        while(len(que)!=0):
            size=len(que)
            tmp=[]
            for i in range(size):
                cur,path=que.pop(0)                
                tmp.append(cur.val)

                if(cur.left==None and cur.right==None and sum(path)==22):
                    print(path)

                if(cur.left):
                    que.append((cur.left,path+[cur.left.val]))
                
                if(cur.right):
                    que.append((cur.right,path+[cur.right.val]))
            res.append(tmp)

        return res


n1=TreeNode(5)
n2=TreeNode(4)
n3=TreeNode(2)
n4=TreeNode(6)

s=Solution()
s.BST_insert(n1,n2)
s.BST_insert(n1,n3)
s.BST_insert(n1,n4)

print(s.bfs(n1))


print("----------------------")
print(s.BST_search(n1,4))
print(s.BST_search(n1,1))