视频笔记

(1)算法与数据结构:
任务的安排,不要先入先出。采用优先队列
加密货币,区块链。
必要条: 算法与数据及结构。
算法和数据结构是有用和有趣的。
Binary Tree 链表和数结合区块链。
(2)如何事半功倍的学习算法
《outliers》
chunk it up  切碎成知识点
Deliberate practicing  刻意练习
Feedback   反馈
星际争霸: 控兵  运营
Sorting  Link_list list spanning tree
Tree_Graph  Stack  Hashing
 
 Abstrack_data_type{
   stack{Vector};
   Queue{Linked List,
     Priority Queue{
      Heap
       }
     };
   SetP{Hash Set,
    Tree Set
    }
   Map{
    Hash Map,
    Tree Map
   }
 }

Data struct  Aglum
刻意练习:
Feedback 反馈:
主动反馈,
被动反馈。算法和面试题。
(03)如何计算算法的复杂度
Algorithm
时间复杂度,空间复杂度。
Big O notation
O(1): 常数级
O(N): for循环
O(N^2):for嵌套
O(log(n)): for(int i=0;i<n;i = i*2)
O(k^N): for(int i=0; i<math.pow(2,n);i++)
O(n!):for(int i=0; i<=factorial(n);i++)
累加: 从O(n)---->O(1);
def fib(n):
 if n==0 or n==1:
  return n
 return fib(n-1)+fib(n-2)
常见的算法:
(4):通过leetCode来进行算法题目练习
坚持,刻意练习
https://leetcode.com/problemset/all/
array[2,7,11,15]  target = 9
return index
/*
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
return 一个对象
*/
class Solution:
 def twoSum(self,nums,target): #nums is array
  hash_map = dict()  #定义一个map
  for i, x  in enumerate(nums):  #枚举
   if target - x in hash_map:  #查找是否存在
    return [i,hash_map[tatget-x]] #如果存在则把两个都返回
   hash_map[x]=i #不存在则放入map

(5)理论讲解
数组插入:时间复杂度O(N)
链表:插入删除O(1)  查找O(N)
[head]  [data,next] [data,next]
 反转链表:
 def reverseList(self,head):
  cur,prev = head, None
  while cur:
   cur.next,prev,cur = prev,cur,cur.next
  return prev
 节点反转:
 def swapPairs(self,head):
  pre, pre.next = self,head
  while pre.next and pre.next.next:
   a = pre.next
   b = a.next
   prev.next, b.next, a.next = b,a,b.next
   pre = a
  return self.next
 判断是否有环:
def hanCycle(self,head):
 fast = slow = head
 while slow and fast and fast.next:
  slow = slow.next
  fast = fast.next.next
  if slow is fast:
   return True
 return False
07 堆栈和队列
消息队列的
www.bigocheatsheet.com
08 判断括号是否有效:
string 大众小括号是否匹配
def isValid(self,s):
 stack = []
 paren_map = {')':'(',']':'[','}':'{'}
 for c in s:
  if c not in  paren_map:   # 返回的是key 是左括号入栈
   stact.append(c)
  elif not stack of paren_map[c] !=stack.pop():
   return False
 return not stack  #如果不为空
 public boolean isValid(String s)
 {
   int lenght;
   do{
    lenght = s.length();
    s = s.replace("()","").replace("{}","").replace("[]","");

   }while(lenght != s.length())
   return s.lenght() == 0
 }
10 优先队列
用堆实现,二叉搜索树 Mini Heap
11 返回数据流中的第k大的元素
12 返回滑动窗口中最大的值
13 映射和集合
HashMap  HashSet  TreeMap  TreeSet
Hash  Function
108+105+101+115  = 429  429%30 = 9 
Hash 碰撞:  拉链法
list_x = [1,2,3,4]
map_x = {
 
 'jack': 100,
 '张三':80,
 'selina':90
}
set_x = {}O(1)的时间复杂度
Hash  的时间复杂度 O(1)
python: 
dict   hashMap
std::unorderedmap
std::map 
14:有效的字母异位
 1 排序  --》对比  时间复杂度: log(n)
 2 使用map 字母计数    时间复杂度: O(N)
Valid Anagram
def isAnagram3(self,s,t):
 return sorted(s) == sorted(t)
def isAnagram1(self,s,t):
 dict1, dict2 = {},{}
 for item in s:
  dict[item] = dict.get(item,0)+1
 for item in t:
 #default -- 如果指定键的值不存在时,返回该默认值值。
  dict[item] = dict.get(item,0)+1
 return dict == dict

def isAnagram2(self,s,t):
 dict1 , dict2 = [0]*26, [0]*26 #创建一个数组
 for item in s:
  dict[ord(item)-ord('a')] +=1
 for item in t:
  dict[ord(item)-ord('a')] +=1
 return dict1 == dict2
16  查找数组中三个数的求和为一个定值
 1 暴力: a,b,c,-->3*Loop
 2 map set 
 3 !Loop sorted find
def threeSum(self,nums):
 if len(nums) < 3:   #数组长度
  return []
 nums.sort()  #排序
 res = set()  #集合
 for i,v in enumerate(nums[:-2]):
  if i >= 1 and v == nums[i-1]:  去重
   continue
  d  = {} 空的字典
  for x in nums[i+1:]:
   if x not in d:
    d[-v-x] = 1
   else:
    res.add((v,-v-x,x))
 return map(list,res)

def threeSum(self,nums):
 res = []
 nums.sort()
 for i in xrange(len(nums)-2):
  if i> 0 and num[i] == nums[i-1]
   continue
  l,r = i+1,len(nums)-1
  while l<r:
   s = nums[i]+ nums[l]+ nums[r]
   if s < 0:  l += 1
   else s > 0: r -=1
   else:
    res.appendd((nums[i],nums[l],nums[r]))
   while l < r and nums[l] == nums[l+1]:  去重处理
    l+=1
   while l < r and nums[r] == nums[r-1]:
    r -= 1
   l +=1 ;r -=1
 return res
Binary Tree
root   sub-tree  left-tree  
分层打印二叉树
Graph:
binary search Tree
18 判断是否是二叉排序树:  时间复杂度
   1中序遍历 后 升序  左 根 右
   2 recursion: validate 
中序变量  左根右
def isValidBST(self,root):  判断是否是二叉树
 inorder = self.inorder(root)
 return inorder = list(sorted(set(inorder)))
def inorder(self,root):
 if root is None:
  return
 return self.inorder(root.letf) + [root.val] + self.inorder(root.right)  返回的序列    低效

中序遍历:  不需要全部罗列,只需要保存当前节点
def isValidBST(self, root):
 self.prev = None;
 return self.helper(root)
def helper(self, root):
 if root is None:
  return True
 if not self.helper(root.left):
  return False
 if self.prev and self.prev.val >= root.val:
  return False
 self.prev = root
 return self.helper(root.right)
 
public boolean isValid(TreeNode root,integer min,Integer max)
{
 if (root == null) return true;
 if (min !=null && root.val <= min) return false;
 if (max != null && root.val >= max) return false;
 return isValid(root.left,mix,root.val)&&
     isValid(root.right,root.val,max);
 
}
19 二叉树二叉树搜索
 1 查找公共祖先: 寻找路径path封装两个节点
找到q记下路径  找到p记下了路径  找到公共系节点
 2 Recursion _findPorq(root,p,q)  时间复杂度 O(N)
  if root == q or root ==p
  findPorq(root.left,p,q)
  findPorq(root.right,p,q)

TreeNode lowestCommonAncestor(TreeNode root, TreeNode p,TreeNode q)

 if (root == null || root == p || root == q) return root;
 TreeNode left = lowestCommonAncestor(root.left, p,q);
 TreeNode right = lowestCommonAncestor(root.right,p,q);
 如果左边也包含 右边也包含  当前节点就是公共节点
 return left == null ? right : right == null ? left : root;
}
二叉搜索树 左边的小于 root 右边的大于root
def lowestCommonAncestor(self, root, p,q):
 if p.val < root.val > q.val:
  return self.lowestCommonAncestor(root.left,p,q)
 if p.val > root.val < q.val:
  return self.lowestCommonAnccestor(root.right,p,q)
 return root
循环方法
def lowestCommonAncestor(self,root,p,q):
 while root:
  if p.val < root.val > q.val:
   root = root.left
  elif p.val > root.val < q.val:
   root = root.right
  else:
   return root
20 二叉树的遍历:
Pre_order  根左右
def preorder(self,root):
 if root:
  self.traverse_path.append(root.val)
  self.preorder(root.left)
  self.preorder(root.right)
In_order   左根右
def inorder(self,root):
 if root:
  self.inorder(root.left)
  self.traverse_path.append(root.val)
  self.inorder(root.right)
Post_order 左右根
def postorder(self,root):
 if root:
  self.postorder(root.left)
  self.postorder(root.right)
  self.traverse_path.append(root.val)
实用度小
实用度高的广度和深度
21 递归&分治
是一种循环。自己调用自己。死循环,死递归
盗梦空间
一层--》二层--三层--四层(中止)--三层--二层--一层
n!
def Factorial(n):
 if n<=1:   终止条件
  return 1
 return n*Factorial(n-1)
开始判断层级,
def recursion(level,param1,param2,...):
 终止条件
 if level > MAX_LEVEL:  到达层次限制 返回
  print_result
  return
  业务逻辑
 process_data(level,data...) 做自己要做的事
 调用下一层
 self.recursion(level+1,p1,..)
 收尾工作
 reverse_state(level)
fib
def fib(n):
 if n==0 or n==1:
  return n
 return fib(n-1)+f(n-2)
分治: Divde& Conquer
动态规划,子问题记忆

def divide_conquer(problem,param1,param2,..)
 if problem is None:
  print_result
  reutrn
 data = prepare_data(problem)
 subproblems = split_problem(problem,data)
 subresult1 = self.divide_conquer(subproblems[0],p1,...)
 subresult1 = self.divide_conquer(subproblems[0],p1,...)
 subresult1 = self.divide_conquer(subproblems[0],p1,...)
 ...
 result = process_result(subresult1,subresult1,subresult1)
Pow(x,n)
    1调用库函数 0(1)
    2暴力;O(N)
    3分治 O(log(n))
def myPow(self,x,n):
 if not m:
  return 1
 if n<0:
  return 1/self.myPow(x,-n)
 if n%2:
  reutrn x*self.myPow(x,n-1)
 return self.myPow(x*x,n/2)
非递归
def myPow(self,x,n):
 if n<0:
  x = 1/x
  n = -n
 pow = 1  用于结果返回
 while n:
  if n&1:
   pow * = x
  x *= x
  n >>=1  等于n除以2
 return pow
23找出的数组的元素的出现的次数大于 2分之长度的element
 1 暴力循环:两层循环 count(x) 复杂度O(N平方)
 2Map {x(key):count(值)} 时间复杂度O(N)
 空间O(N)
 3sort 时间复杂度O(NlogN)
 4分治 数组一分为二,左边寻找 右边查找
 return count(left) > count(right) ? left : right
 时间复杂度O(NlogN)
24贪心算法
在当前看来最好选择
算价值36的面额的纸币
问题能过分成子问题来解决。最优子结构。
贪心算法,对每个子问题的解决方案都做出选择,不能回退。 动态规划则会保存以前的运算结果。并根据以前的结果对当前进行选择。有回退功能。
25买卖股票问题
 搜索贪心算法
 最多持有1股  买卖无数次
 1 搜索DFS 时间复杂度O(N)
 2 贪心法每日买卖O(n)
 3 DP时间复杂度O(n)
26 广度优先搜索
 寻找特定的节点。在二叉树中怎么查找value == 100
 计算机查找: 内存扫荡,整个数据的扫荡
 一层一层访问。地毯式搜索。将一层一层的加入队列。
def BFS(graph,start,end):
 queue = []  数组
 queue.append([start])
 visited.add(start)  任何被访问的加入集合
 while queue:
  node = queue.pop()
  visited.add(node)  标记已经被访问过
  process(node)
  找后继节点,没有没有被问过 访问
  nodes = generate_related_nodes(node)
  queue.push(nodes)
27 深度优先搜索
 为什么要深度搜索?计算机一根经一查到底。
visited = set()  保存访问过的节点
def dfs(node,visited):
 visited.add(node)
 ...
 for next_node in node.children:
  if not next_node in visited:
   dfs(next_node,visited)
def DFS(self,tree):
 if tree.root is Node:
  return []
 visited,stackt = [],[tree.root]
 while stack:
  #访问节点
  node = stack.pop()
  添加到访问集
  visited.add(node)
  process(node)
  nodes = generate_related_nodes(node)
  stack.push(nodes)
28 对二叉树按层输出节点:
 1 BFS  广度优先 判断属于那一层
   循环  时间复杂度O(N)
 2 DFS  数组,记住深度。
class Solution(object):
 def levelOrder(self,root):
  if not root: return []
  result = []
  queue = collections.deque() 双端队列
  把根节点加入
  queue.append(root)
  #visited = set(root)
  while queue:
   取出层的长度
   level_size = len(queue)
   current_level = []
   for _ in rang(level_size):
    #取出当前层中队列中的节点
    node = queue.popleft()
    取出当前层中节点的值
    current_level.append(node.val)
    把节点的下一层放入队列
    if node.left: queue.append(node.left)
    if node.right: queue.append(node.right)
   result.append(current_level)
  return result
深度优先
class Solution(object):
 def levelOrder(self,root): 获得根节点
  if not root: return []
  self.result = []  返回集
  self._dfs(root,0) 调用函数
  return self.result
  参数: 节点 深度
  私有函数
 def _dfs(self,node,level):
  if not node: return 
  结果比当前行还要小
  if len(self.result) < level+1:
   self.result.append([])
   一维为层  二维为值
  self.result[level].append(node.val)
  self._dfs(node.left,level+1)
  self._dfs(node.right,level=1)

29 二叉树最大最小的深度:
 2 BFS 按层扫荡 判断是否是叶子接待你
 3 退进,记住max ,min 时间复杂度o(n)
找最大深度;
class Solution:
 def maxDepth(self,root):
  if not root: return 0
  1 自己本身深度的一层
  return 1+max(self.maxDepth(root.left),self.maxDepth(root.right))
class Solution{
 public:
  int minDepth(TreeNode* root)
  {
   if(!root) return 0;
   if(!root->left) return 1+minDepth(root->left);
   if(!root-right) return 1+minDepth(root->right)
   分治
   int leftMinDepth = minDepth(root->left);
   int rightMinDepth = minDepth(root->right);
   返回当前层的最小深度
   int result = 1 + min(leftMinDepth,rightMinDepth);
   return result; 
  }

}
java
public class Solution{
 public int minDepth(TreeNode root){
 if (root == NULL) return 0;
 int left = minDepth(root.left);
 int right = minDepth(root.right);
  左右的较小者加1
 return (left ==0 || right ==0) ? left + right +1 : Math.min(left,right)+1;
 }
}

30 生成括号:
 给定一个n , 输出所有匹配的括号
 1 数学归纳法
 2 递归搜索,字符串的长度为2 * n
 把所有的可能配皮全部罗列出来,去除不合法的
 3 1 局部不合法减枝,不再递归
   2 leftused, rightused O(2的n次方)
class Solution(object);
 def generationParenthesis(self,n):
  self.list = []
  self._gen(0,0,n," ")
  return self.list
  左边的括号已经用了多少个
 def _gen(self,left,right,n,reslet):
 终止条件 括号的数量是否已经用完了
  if left == n and right ==n:
   self.list.append(result)
   return
  if left < n:
   self._gen(left + 1,right, n,result+"(")
  if left > right and right < n:
   self._gen(left,right+1,n,result +")")
31 剪枝
32 N-queues
    DFS 搜索
    枚举列,第一层放置位置,判断能不能方
    1 暴力
    2 剪枝 数组row[i],col[j] 把行和列标志为1
    pie[i+j] = 1
    na[i-j] = 1
    遍历level 判断当前层是否有i,j是否满足
    遍历下一层
def solveNQueue(self,n):
f
 if n<1 return []
 结果集
 self.result = []
 self.cols = set();self.pie = set();self.na = set()
 self.DFS(n,0,[])
 return self.result
def DFS(self,n,row,cur_state):
 终止条件
 if row >=n:
  把结果放入结果集
  self.result.append(cur_state)
  return
 for col in rang(n):
  列被之前占用
  if col in self.cols or row + col in self.pie or row -col in self.na:
   continue
   把皇后放入这个位置
  没有占用把这一行放入结果集 
  self.cols.add(col)
  self.pie.add(row+col)
  self.na.add(row-col)
  self.DFS(n,row+1,cur_state+[col])
  清空现场
  self.cols.remove(col)
  self.pie.remove(row+col)
  self.na.remove(row-col)
def _geerate_result(self,n):
 board = []
 for res in self.result:
  for i in res:
   board.append(.*i+'Q'+'.'*(n-i))
 return [board[i: i+n] for i in range(0,len(board),n)]
 range(start, stop[, step])
参数说明:
start: 计数从 start 开始。默认是从 0 开始。例如range(5)等价于range(0, 5);
stop: 计数到 stop 结束,但不包括 stop。例如:range(0, 5) 是[0, 1, 2, 3, 4]没有5
step:步长,默认为1。例如:range(0, 5) 等价于 range(0, 5, 1)
def so(self,n):
     def df(queue,xy_dif,xy_sum):
             p = len(queue)
             if p == n:
                     result.append(queue)
                     return None
             for q in range(n):
                     if q not in queue and p-q not in xy_dif and p+q not in xy_sum:
                             df(queue+[q],xy_dif+[p-q],xy_sum+[p+q])
     result = []
     df([],[],[])
     生成二维数组
     print ([["."*i+"Q"+"."*(n-i-1) for i in sol] for sol in result])
public void solveSudoku(char[][] board)
{
 if (board == null || board.lenght ==0) return ;
 solve(board);
}
public blooean solve(char [][] board)
{
 for (int i = 0; i < board.length;i++) for (int j < board[0].length; j++){
   if (board[i][j] == "."){
        for (char c = '1'; c <= '9'; c++){
          if (isvalid(board,i,j,c)){
      board[i][j] = c;
       递归调用
       if (solve(board))
      return true
       else
        不然 还原
      board[i][j] = '.';
     }end 判断合法
       }end 枚举可以放入的字符
       1-9 都不能放入 返回
       return  false;
     } end 判断是否为空格
    }
 return true
}
// 判断是否有重复的
private boolean isValid(char[][] board, int row, int col, char c){
 // 9*9的方格
 for(int i = 0;i < 9; i++)
 {
   if(board[i][col] != '.' && board[i][col] ==c) return false;  // check row
   if(board[row][i]!= '.' && board[row][i]== c) return false; check column
   if(board[3*(row/3) + i /3][3* (col/3)+i%3] !='.' && board[3*(row/3) + i /3][3* (col/3)+i%3]  == c) return false; //check 3*3
 }
return true;
}

34 二分查找  时间复杂度log(n)
left, right = 0,len(array)-1
while left <= right:
 mid = (left + right)/2
 if array[mid] == target:
   brear or return result
 elif array[mid] < target :
   left = mid + 1
 else :
  right = mid -1

35  开平方
 target = 5
 1 二分法查找
 2 牛顿迭代法
double squrt(int x, double flag){
 if(x == 0||x == 1) return x;
 int l = 1, r = x, res;
 while (l <=r){
   int m = (l+r)/2
   if (m == x/m){
   return m;
   }else if (m > x /m)  更新右边界
   {
    r = m-1;
   }else{ 更新左边界
   l = m+1;
   res = m;  跳出循环后的返回
   }
 }
return res;
}
牛顿迭代法:
class Solution(object):
 def mySqurt(self,x):
  r = x
  while r*r > x:
   r = (r+ x/r) /2
  return r
36 字典树
 trie数据结构,最大限度查询
 空间换时间的办法。
 根节点不包含字符, 路径上对应的字符组成的
 字节不相同。
static final int ALPHTABLET_SIZE = 256
static class TrieNode{
 //有一个孩子节点数组
 TrieNode[] children = new TrieNode[ALPHTABLET_SIZE];
 // 是不是字符
 boolean isEndOfword = false;
 TriNode(){
 isEndOFWord = false; //不是字符
 for (int i =0;i < ALPHTABLET_SIZE; i++)
 {
  children[i] = NULL;  初始化孩子节点
 }

 }
}

public class Solution{
 Set<string> res = new HashSet<string>();
 public List<string> findWords(char[][] board,String[] words){
  创建一个字典树
  Trie trie = new Trie();
  把要匹配的字母添加到字典树中
  for (String word: words)
  {
   trie.insert(word);
  }
  字母表的维度和长度
  int m = board.lenght();
  int n = board[0].length();
  boolenn[][] visited = new boolean[m][n];
  for (int i = 0; i < m;i++)
   for (int j = 0;j < n;j++){
    dfs(board,visited,"",i,j,trie);
   }
 }
 return new ArrayList<string>(res)
}
public void dfs(char[][] board,boolean[][] visited,String str, int x,int y, Trie tire){
 if(x < 0 || x >= board.length || y < 0 || y>=board[0].lendgth) return ;
 如果被访问过
 if (visited[x][y]) return ;
 str +=board[x][y];
 是不是前缀
 if(!trie.startWith(str)) return;
 if(trie.seach(str)){
 res.add(str);
 }
 改变访问标志
 visited[x][y] = true;
 递归遍历左边
 dfs(board,visited,str,x-1,y,trie);
 递归调用右边
 dfs(board,visited,str,x+1,y,trie);
 递归调用下边
 dfs(board,visited,str,x,y-1,trie);
 递归调用上边
 dfs(board,visited,str,x,y+1,trie);
 visited[x][y] = false;
}
字典树
class TrieNode:
 def __init__(self):
  // type of  list
  self.children = [None] * ALPHTABLET_SIZE
  self.isEndofWord = False
方向数组
dx = [-1,1,0,0]
dy = [0,0,-1,1]
END_OF_WORD = "#"
class Solution(object):
   参数判断
 def findWords(self, board, words):
  if not board or not board[0]: return []
  if not words: return []
  装载结果
  self.result = set()
  Python中通过Key访问字典,当Key不存在时,会引发‘KeyError’异常。为了避免这种情况的发生,可以使用collections类中的defaultdict()方法来为字典提供默认值。
  空的字典
  字典树的节点
  root = collections.defaultdict();
  把
  for word in words:
   node = root
   for char in word:
    node = node.setdefault(char,collection.defaultdict())
   node[END_OF_WORD]=END_OF_WORD
  字母表的大小
  self.m self.n = len(board),len(board[0])
  for i in xrange(self.m):
   for j in xrange(self.n):
    是否是前缀
    if board[i][j] in root:
     self._dfs(board,i,j,"",root)
 def _dfs(self,board,i,j,cur_word,cur_dict)
  现在单词
  cur_word +=board[i][j]
  字典树的层
  cur_dict = cur_dict[board[i][j]]
  是不是已经找到单词
  if END_OF_WORD in cur_dict:
   self.result.add(cur_word)
    标记是否被访问过
  tmp, board[i][j] = board[i][j], '@'
  xrange() 函数用法与 range 完全相同,所不同的是生成的不是一个数组,而是一个生成器。
  for k in xrang(4):
   x,y = i + dx[k],j+dy[k]
   if 0 <=x<self.m and 0 <=y<=self.n \
   and board[x][y]!='@' and board[x][y] \
   in cur_dict:
    self._dfs(board,x,y,cur_word,cur_dict)
  恢复
  board[i][j] = tmp
class Trie(object):
 def __init__(self):
  self.root = {}
  self.end_of_word = "#"
 def insert(self,word):
  node = self.root
  for char in word:
   node = node.serdefault(char,{})
  node[self.end_of_word] = self.end_of_word
 def search(self,word):
  node = self.root
  for char in word:
   if char not in node:
    return false
   node = node[char]
  return self.end_of_word in node
 def startsWith(self,prefix):
  node = self.root
  for char in prefix:
   if char not in node:
    return false
   node = node[char]
  return True
字典树
class TrieNode{
 public char val
 public boolean isword;
 定义一个数组  每个节点都有26个孩子节点
 public TrieNode[] children = new TrieNode[26]
 public TrieNode() {}
 有参构造
 TrieNode(char c){
  TrieNode node = new TrieNode();
  node.val = c
 }
}
public class Trie{
 private TrieNode root
 public Trie(){
  根节点
  root = new TriedNode();
  root.val = "";

 }
 public void insert(String word){
  TrieNode ws = root;
  for(int i=0;i< word.length();i++)
  {
   char c = word.charAt(i);
   当c  不存在 创建一个新的
   if(ws.children[c-'a'] == null){
    ws.children[c-'a'] = new TriedNode(c);
   }
   ws = ws.children[c-'a'];
  }
  ws.isWord = true;
 }
 public boolean search(String word){
  TrieNode ws = root;
  //查找是否存在
  for(int i = 0;i< word.length;i++){
   char c = word.charAt(i);
   if(ws.children[c-'a'] == null) return false;
   ws = ws.children[c-'a'];
  }
  return ws.isword;
 }
 public boolean startWitch(String prefix)
 {
  TrieNode ws = root;
  for (int i =0;i< prefix.length();i++){
   char c = prefix.charAt(i);
   if (ws.children[c-'a'] == null) return false;
   ws = ws.children[c-'a'];
  }
  return true;
 }

}
39 位运算
 对二进制操作。
 & | ^ ~
 判断奇偶  X &1 == 1 or ==0
 最低为清零: x = x &(x-1)
40 统计bit1的个数
 1) x% 2 if ==1 count ++
  x = x>>1  时间复杂度 O(n)
 2) x = x&(x-1)
  while(x!=0){
  count ++;
  x = x&(x-1)
  }
def hammingweight(self,n):
 rst = 0
 mask = 1
 for i in range(32):
  if n & mask:
   rst +=1
  mask = mask >>1
 return rst
int hamingWeith(uint32_t n){
 int rst = 0;
 for(;n; n&=n-1)
 ++rst;
 return rst;
}

41 2的幂次方
  1) 循环模2
  2)位运算  x!=0 && x(x-1) ==0
  1) for i=0 ==>n count.bit(i)
  2)for (int i=0; i<n;i++)
  count[i] = count[i&(i-1)]+1

  bool isPowerOfTwo(int n){
  return n>0 && !(n&(n-1))
  }
def isPowerOfTwo(self,n):
 return n>0 and not (n&(n-1))
vector<int> countBits(int num){
 定义要给数组大小位 nums+1 初始值为0
 vector<int> bits(nums+1,0);
 for (int i =1; i<=nums; i++){
 地推
  bits[i] += bits[i&(i-1)] +1;
 }
return bits;
}
posted @ 2019-09-15 12:14  countryboy666  阅读(249)  评论(0编辑  收藏  举报