数据结构极客视频5_二分和字典序

二分查找

二分查找应用条件

二分查找代码模板

left,right=0,len(array)-1
while left<=right:
    mid==(right+left)/2
    if array[mid]==target:
        break or return  result
    elif array[mid]<target:
        left=mid+1
    else:
        right=mid-1

二分题目 实现sqrt

注意需要保存最左边的那个l

class Solution {
    public int mySqrt(int x) {
        if(x==0 || x==1)
            return x;
        int  l=0;
        int r=x;
        int ret=0;
        while(l<=r){
            int mid=(l+r)/2;
            if(mid==x/mid){
                return mid;
            }
            else if(mid<(x/mid)){
                l=mid+1;
                ret=mid;
            }
            else {r=mid-1;                 
                 }
            
        }
        return ret;
    }
}

字典树

字典树 leetcode208

• 解法：使用了一个字典 每次插入一个字符 字典深度加1 比如：单词abcded {a:{b:{c:{d:{e:{f:{end}}}}}}}

class Trie:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.root={}
        self.end='#'
        

    def insert(self, word: str) -> None:
        """
        Inserts a word into the trie.
        """
        node = self.root
        for i in word:
            node = node.setdefault(i,{})
        node[self.end]=self.end
        

    def search(self, word: str) -> bool:
        """
        Returns if the word is in the trie.
        """
        node =  self.root
        for i in word:
            if i not in node:
                return False
            node=node[i]
        return self.end in node
    def startsWith(self, prefix: str) -> bool:
        """
        Returns if there is any word in the trie that starts with the given prefix.
        """
        node =self.root
        for i in prefix:
            if i not in node:
                return False
            node=node[i]
        return True
        

字典树 leetcode212：

• 思路 先把那几个单词建立个字典树 然后再board中遍历 进行搜索字典树中的第一层 如果匹配进入深度优先

class Solution:
    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
        self.dx=[1,-1,0,0]
        self.dy=[0,0,1,-1]
        self.end="#"
        
        if not board or not words:
            return []
        self.result = set()
        root =collections.defaultdict()
        
        for word in words:
            node = root
            for c in word:
                node=node.setdefault(c,collections.defaultdict())
            node[self.end]=self.end
        
        self.m,self.n= len(board),len(board[0])
        
        for i in range(self.m):
            for j in range(self.n):
                if board[i][j] in root:
                    self._dfs(board,i,j,"",root)
        return list(self.result)
    
    def _dfs(self,board,i,j,cur_word,cur_dic):
        cur_word+=board[i][j]
        cur_dic = cur_dic[board[i][j]]
        
        if self.end in cur_dic:
            self.result.add(cur_word)
            
        tmp = board[i][j]
        board[i][j]="*"
        for ind in range(4):
            x,y=i+self.dx[ind],j+self.dy[ind]
            if 0<=x<self.m and 0<=y<self.n and board[x][y] in cur_dic and board[x][y]!="*":            
                self._dfs(board,x,y,cur_word,cur_dic)
        board[i][j]=tmp