每日刷题 Day18

题一：只出现一次的数字
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:
输入: [2,2,1]
输出: 1

示例 2:
输入: [4,1,2,1,2]
输出: 4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/single-number

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        //使用哈希表
        unordered_map<int,int> str;
        //以数组中具体数值为key，每个数字在数组中出现次数为value值
        for(int i=0;i<nums.size();i++){
            str[nums[i]]++;
        }
        int temp;
        for(auto p:str){    //对哈希表进行遍历
            if(p.second==1)  //寻找value值为1的元素
            {
                temp=p.first;   //记录出现一次的元素
                break;  
            }
                
        }
        return temp;
    }
};

题二：Sqrt(x)
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：
输入：x = 4
输出：2

示例 2：
输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。

提示：
0 <= x <= 231 - 1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sqrtx

class Solution {
public:
    int mySqrt(int x) {
        if(x==0)
            return 0;
        //使用二分查找
        int l=0,r=x,mid=-1;
        int ans;//用来存结果
        while(l<=r){
            mid=(l+r)/2;
            if((long long)mid*mid<=x){
                ans=mid;
                l=mid+1;
            }
            else{
                r=mid-1;
            }
        }
        return ans;
    }
};

题三：平衡二叉树
给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：true

示例 2：
输入：root = [1,2,2,3,3,null,null,4,4]
输出：false

示例 3：
输入：root = []
输出：true

提示：
树中的节点数在范围 [0, 5000] 内
-104 <= Node.val <= 104

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/balanced-binary-tree

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int judgeTree(TreeNode* root){  //计算树的高度
        if(root==NULL)  return 0;
        int left=judgeTree(root->left);
        int right=judgeTree(root->right);
        return 1+max(left,right);
    }
    bool isBalanced(TreeNode* root) {
        if(root==NULL)  return true;
        int left=judgeTree(root->left);
        int right=judgeTree(root->right);
        if(abs(right-left)>1)   //左右子树高度差大于一时，说明不是平衡二叉树
            return false;
        return isBalanced(root->left)&&isBalanced(root->right);
    }
};