二叉树的深度

题目描述

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

思路

• 递归回溯

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public:
    int deep(TreeNode * root, int depth)
    {
        if (root == nullptr)
            return depth;
        else
            return max(deep(root->left, depth + 1), deep(root->right, depth + 1));
    }
    int TreeDepth(TreeNode* pRoot)
    {
        return deep(pRoot, 0);
    }
};

平衡二叉树

题目描述

输入一棵二叉树，判断该二叉树是否是平衡二叉树。

思路

• 平衡二叉树：任意节点的左子树的深度和右子树的深度最多相差1

class Solution {
public:
    bool Isbalanced(TreeNode* root, int &depth)
    {
        if (root == nullptr)
        {
            depth = 0;
            return true;
        }

        int left, right;
        if (Isbalanced(root->left, left) && Isbalanced(root->right, right))
        {
            int dif = left - right;
            if (dif >= -1 && dif <= 1)
            {
                depth = 1 + max(left, right);
                return true;
            }
        }
        return false;
    }

    bool IsBalanced_Solution(TreeNode* pRoot) {
        int depth = 0;
        return Isbalanced(pRoot, depth);
    }
};

和为S的两个数字

题目描述

输入一个递增排序的数组和一个数字S，在数组中查找两个数，是的他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

思路

• O(n): 尺取法
• O(nlogn):二分法，枚举x，用二分判断S-x是否存在

class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum) {
        vector<int> ans;
        int n = array.size();
        if (n == 0)
            return ans;
        for (int l = 0, r = n - 1; r > l; )
        {
            int tmp = array[l] + array[r];
            if (tmp == sum)
            {
                ans.push_back(array[l]);
                ans.push_back(array[r]);
                return ans;
            }
            else if (tmp < sum)
                l++;
            else
                r--;
        }
        return ans;
    }
};

数组中只出现一次的数字

题目描述

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

思路

• 如果出现1次的数只有一个，那就所有数进行异或，相等的进行抵消，所以最后剩下的那个数字就是出现1次的数。
• 如果是2个数，就要把原数组分为2个部分，确保这2个数分在不同的部分，然后2个部分分别进行异或。
• 这2个数肯定不相同。所以按照这2个数异或之和的最后一位是否为1进行分组。首先2数不同异或和必定不为0，肯定有某一位为1，该位为1表示0^1。所以所有数根据这一位为0还是1进行分开。

class Solution {
public:
    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
        int n = data.size();
        int orsum = 0;
        for (int i = 0; i < n; i++)
            orsum ^= data[i];

        int index = GetIndex(orsum);
        for (int i = 0; i < n; i++)
        {
            if (IsBit(data[i], index) == 0)
                *num1 ^= data[i];
            else
                *num2 ^= data[i];
        }
    }

    int GetIndex(int x)
    {
        int index = 0;
        while (x)
        {
            if ((x & 1) == 1)
                return index;
            index++;
            x >>= 1;
        }
        return index;
    }

    int IsBit(int x, int index)
    {
        return ((x >> index) & 1);
    }
};