leetcode-C++

single-number

题目描述
现在有一个整数类型的数组，数组中素只有一个元素只出现一次，其余的元素都出现两次。

分析：
题目说了除了一个数字外，其他的都会出现两次，因此我们可以使用异或的方法来找出那个数。

因为a xor a xor b = b。
因此我们只要让数组中的每一个数字异或一下就能够得出结果了。
开始有点疑惑为什么-1^3=-4,后面想了一下是对每个数的二进制进行逐位异或的。

class Solution {
public:
    /**
     * 
     * @param A int整型一维数组 
     * @param n int A数组长度
     * @return int整型
     */
    int singleNumber(int* A, int n) {
        int result{*A};
        for (int* i = A+1;*i<n;i++) {
            result = result ^ *i;
        }
        return result;
    }
};

maximum-depth-of-binary-tree

题目描述
求给定二叉树的最大深度，
最大深度是指树的根结点到最远叶子结点的最长路径上结点的数量。

分析：
使用递归的方法：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param root TreeNode类 
     * @return int整型
     */
    int maxDepth(TreeNode* root) {
        if(root==NULL){
            return 0;
        }
        int leftnum = maxDepth(root->left);
        int rightnum = maxDepth(root->right);
        if (rightnum>leftnum){
            return rightnum+1;
        }
        return leftnum+1;
    }
};

Same Tree

题目描述
给出两个二叉树，请写出一个判断两个二叉树是否相等的函数。
判断两个二叉树相等的条件是：两个二叉树的结构相同，并且相同的节点上具有相同的值。

使用递归的方法：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param p TreeNode类 
     * @param q TreeNode类 
     * @return bool布尔型
     */
bool isSameTree(TreeNode* p, TreeNode* q) {
        if(q && p && (q->val == p->val)){
            if(isSameTree(p->left,q->left) && isSameTree(p->right,q->right)){
                return true;
            }else{
                return false;
            }
        }
        if(q==NULL && p==NULL){
            return true;
        }else{
            return false;
        }
}
};

大佬的简化写法，这也太秀了吧。。。。

bool isSameTree(TreeNode *p, TreeNode *q) {
    if (p == NULL || q == NULL) return (p == q);
    return (p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right));
}

binary-tree-preorder-traversal

题目描述
求给定的二叉树的前序遍历。
例如：
给定的二叉树为{1,#,2,3},

返回：[1,2,3].
备注；用递归来解这道题很简单，你可以给出迭代的解法么？

使用迭代的方法

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode* temp = root;
        while(!s.empty() || temp){
            while(temp){
                s.push(temp);
                res.push_back(temp->val);
                temp = temp->left;
            }
            temp = s.top();
            s.pop();
            temp = temp->right;
        }
        return res;
    }
};

reverse-integer

题目描述
将给出的整数x翻转。
例1:x=123，返回321
例2:x=-123，返回-321

你有思考过下面的这些问题么？
如果整数的最后一位是0，那么输出应该是什么？比如10,100
你注意到翻转后的整数可能溢出吗？假设输入是32位整数，则将翻转10000000003就会溢出，你该怎么处理这样的样例？抛出异常？这样做很好，但是如果不允许抛出异常呢？这样的话你必须重新设计函数（比如添加一个额外的参数）。

这个题爷就没考虑溢出的情况，随便写了一下居然还过了。。。。。

class Solution {
public:
    /**
     * 
     * @param x int整型 
     * @return int整型
     */
    int reverse(int x) {
    int t{ 0 };
    int flag{ 0 };
    if (x < 0) {
        x = -x;
        flag = 1;
    }
    while (x > 0)
    {
        t = t * 10 + x % 10;
        x = x / 10;
    }
    return flag?-t:t;
    }
};

palindrome-number

题目描述
在不使用额外的内存空间的条件下判断一个整数是否是回文数字
提示：
负整数可以是回文吗？（比如-1）
如果你在考虑将数字转化为字符串的话，请注意一下不能使用额外空间的限制
你可以将整数翻转。但是，如果你做过题目“反转数字”，你会知道将整数翻转可能会出现溢出的情况，你怎么处理这个问题？

反转数字：

class Solution {
public:
    /**
     * 
     * @param x int整型 
     * @return bool布尔型
     */
    bool isPalindrome(int x) {
        int t{ 0 };
    	int flag{ 0 };
	    int tmp{ x };
	    while (tmp > 0)
	    {
	        t = t * 10 + tmp % 10;
	        tmp = tmp / 10;
	    }
	    return (t == x ? true : false);
	    }
};

不反转：