小白笔记---------------------（算法总结）（1）

小白笔记———————（算法总结）（1）

二分搜索算法

• 解决问题：从数组中查找已知存在的数的位置
• 前提条件：一个已经排好序的整型数组
• 一般解决方式：遍历数组，找到第一次出现的要找的数，返回它的位置
• 使用价值：除非特别指定用二分搜索算法，大部分情况下都能用一层循环解决

求众数

• 解决问题：求整型数组中出现次数最多的数
• 一般解决方法：用一个数组记录每个数出现的次数，遍历这个数组找到最大值，返回原数组该位置的值，就是结果
• 价值：很多算法题中涉及的子问题就是求众数，需要重视
• 常用算法：
  

   
  
  int[] max_num = new int[arr.length]; 
  
  for(int i = 0; i < arr.length;i++){ 
  
  for(int j = 0; j < arr.length;j++){ 
  
  if(arr[i] == arr[j]){ 
  
    max_num[i]++; 
  
  } 
  
  } 
  
  } 
  
  int max = 0; 
  
  int tap = 0; 
  
  for（int k;k < arr.length;k++） 
  
  { 
  
  if(arr[k] > max){ 
  
   max = arr[k]; 
  
   tap = k; 
  
  } 
  
  } 
  
  return arr[tap]; 
  
  

求质数

• 解决问题：求出小于n的所有质数
• 解决方法：有一个取巧的算法,将不是质数的数排除之后确定质数的个数
• 算法：
  

   
  
  int countPrimes(int n) { 
  
  if(n <= 2){ 
  
      return 0; 
  
  } 
  
  int i, j,g,k; 
  
  bool count[n]; 
  
  for(g = 0;g < n;g++){ 
  
      count[g] =true; 
  
  } 
  
  for(i = 2; i * i < n; i++){ 
  
      if(count[i]){ 
  
          for(j = 2; i * j < n;j++){ 
  
              count[i*j] = false; 
  
          } 
  
      } 
  
  } 
  
  int sum = 0; 
  
  for(k = 2;k < n;k++){ 
  
      if(count[k] == true){ 
  
          sum++; 
  
      } 
  
  } 
  
  return sum; 
  
  } 
  
  

• 用途：在遇到求小于某个值的质数时非常有帮助，解题的思路也值得借鉴

求长字符串的反转

• 解决问题：求所给字符串的反转
• 一般算法：将字符串分解成字符数组，然后一一反向赋值
• 应用场景：在一些字符串问题中作为子问题存在

求二叉树左子叶的和

• 问题关键：涉及到二叉树的很多问题都需要用到递归
• 算法：
  

   
  
  /**  
  
  
       
       
       
       
  
        
        
        
        
  Definition for a binary tree node. 
  
        
        
        
        
  struct TreeNode { 
  
        
        
        
        
  int val; 
  
        
        
        
        
  struct TreeNode *left; 
  
        
        
        
        
  struct TreeNode *right; 
  
        
        
        
        
  }; 
   */ 
   int sumOfLeftLeaves(struct TreeNode* root) { 
   if(root == NULL) return 0; 
   if(root->left != NULL){ 
   if(root->left->left == NULL && root->left->right == NULL){ 
   return root->left->val + sumOfLeftLeaves(root->right); 
   } 
   } 
   return sumOfLeftLeaves(root->left) + sumOfLeftLeaves(root->right); 
   } 
   
       
       
       
       

先总结到这儿，下期继续！