Add Digits, Maximum Depth of BinaryTree, Search for a Range, Single Number,Find the Difference

最近做的题记录下。

258. Add Digits

Given a non-negative integer num, repeatedly add all its digits until the result has only one digit.

For example:

Given num = 38, the process is like: 3 + 8 = 11, 1 + 1 = 2. Since 2 has only one digit, return it.

 int addDigits(int num) {
         char strint[] = {};
         sprintf(strint, "%d", num);
         int i=,a = ;
         while(strint[i+]!= '\0')
         {
            a = (strint[i]-'')+(strint[i+]-'');
            if(a>)
            {
                 a = a%+a/;
            }
            strint[++i] = a+'';
         }
         return strint[i]-'';
 }

上边这是O(n)的复杂度。网上还有O(1)的复杂度的：return (num - 1) % 9 + 1;

104. Maximum Depth of Binary Tree

求二叉树的深度，可以用递归也可以用循环，如下：

 /**
  * Definition for a binary tree node.
  * struct TreeNode {
  *     int val;
  *     struct TreeNode *left;
  *     struct TreeNode *right;
  * };
  */
 int maxDepth(struct TreeNode* root) {
     int left = ,right = ;
     if (root == NULL) return ;

     left = maxDepth(root->left);
     right = maxDepth(root->right);

     return left>right? left+:right+;
 }

******************************************************************************************************************

用队列存结点，记录每一层的结点数levelCount，每出一个结点levelCount--，如果减为0说明要进入下一层，然后depth++，同时队列此时的结点数就是下一层的结点数。

 /**
  * Definition for a binary tree node.
  * struct TreeNode {
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
 class Solution {
 public:
     int maxDepth(TreeNode* root) {
         if (root == NULL) return ;

         //深度和每一层节点数
         int depth = ,levelCount = ;
         //队列保存每一层的节点数
         queue<TreeNode*> node;

         node.push(root);
         while(!node.empty())
         {
             //依次遍历每一个结点
             TreeNode *p = node.front();
             node.pop();
             levelCount--;

             if(p->left) node.push(p->left);
             if(p->right) node.push(p->right);

             if (levelCount == )
             {
                 //保存下一层节点数，深度加1
                 depth++;
                 levelCount = node.size();
             }
         }
         return depth;
     }
 };

34. Search for a Range

Given a sorted array of integers, find the starting and ending position of a given target value.

Your algorithm's runtime complexity must be in the order of O(log n).

If the target is not found in the array, return [-1, -1].

For example,

Given [5, 7, 7, 8, 8, 10] and target value 8,

return [3, 4]

 vector<int> searchRange(vector<int>& nums, int target) {
         int size = nums.size();
         int l=,r=size-;
         while(l<=r)
         {
             int mid = (l+r)/;
             if (nums[mid] >= target)
             {
                 r = mid-;
             }
             else if(nums[mid] < target)
             {
                 l = mid+;
             }
         }
         int left = l;
         l = ;
         r = size-;
         while(l<=r)
         {
             int mid = (l+r)/;
             if (nums[mid] <= target)
             {
                 l = mid+;
             }
             else if(nums[mid] > target)
             {
                 r = mid-;
             }
         }
         int right = r;
         vector<int> v;
         v.push_back(left);
         v.push_back(right);
         if(nums[left] != target || nums[right] != target)
         {
             v[] = -;
             v[] = -;
         }
         return v;
     }

这个题就是要把握好边界，比如找左边界时 =号要给右边界的判断，找右边界则相反。这样才能保证不遗漏

136. Single Number

Given an array of integers, every element appears twice except for one. Find that single one.

直接用异或

 int singleNumber(vector<int>& nums) {
         int result=;
         int len = nums.size();
         if (len <=) return ;
         for(int i=;i<len;i++)
         {
             result ^= nums[i];
         }
         return result;
     }

389. Find the Difference

Given two strings s and t which consist of only lowercase letters.

String t is generated by random shuffling string s and then add one more letter at a random position.

Find the letter that was added in t

 

这种方法挺慢，我提交显示16ms，没有那种用char数组来模拟hash快。

 char findTheDifference(string s, string t) {
         map<char, int> sumChar;
         char res;
         for(auto ch: s) sumChar[ch]++;
         for(auto ch: t)
         {
            if(--sumChar[ch]<)
                res = ch;
         }
         return res;
     }

这道题也可以用异或 因为相同的会异或掉，剩下一个就是多余的char。