剑指 Offer-Day6

剑指 Offer 28. 对称的二叉树

题目链接

题目描述：

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

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

限制：

0 <= 节点个数 <= 1000

思路：

是否为对称二叉树的判断方法：

1、空树是对称二叉树

2、单个结点的树是对称二叉树

3、若左子树和右子树有一个为空，则不是对称二叉树

4、左子树的左孩子等于右子树的右孩子且左子树的右孩子等于右子树的左孩子，是对称二叉树

5、剩下情况均不是对称二叉树

代码：

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if(!root){
            return true;
        }
        return isSymmetric(root->left,root->right);
    }
    bool isSymmetric(TreeNode *root1,TreeNode *root2){
        if(!root1 && !root2){
            return true;
        }
        if(!root1 || !root2){
            return false;
        }
        return root1->val==root2->val && isSymmetric(root1->left,root2->right) 
            && isSymmetric(root1->right,root2->left);
    }
};

剑指 Offer 30. 包含min函数的栈

题目链接

题目描述：

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.min();   --> 返回 -2.

提示：

各函数的调用总次数不超过 20000 次

思路：

1、创建两个栈s1和s2，s2为辅助栈

2、push：若s1为空，则分push进s1和s2，若s1不为空，则需要比较x和s2的栈顶元素的大小关系，若x>s2.top，则s2.top入栈，否则，x入栈

3、pop：将s1和s2分别pop

4、top：返回s1的top

5、min：返回s2的top

举例：

步骤	操作	数据栈	辅助栈	最小值
1	压入3	3	3	3
2	压入4	3,4	3,3	3
3	压入2	3,4,2	3,3,2	2
4	压入1	3,4,2,1	3,3,2,1	1
5	弹出	3,4,2	3,3,2	2
6	弹出	3,4	3,3	3
7	压入0	3,4,0	3,3,0	0

代码：

class MinStack {
public:
    /** initialize your data structure here. */
    stack<int> s1;
    stack<int> s2;
    MinStack() {

    }
    
    void push(int x) {
        if(s1.empty()){
            s2.push(x);
        }
        s1.push(x);
        if(x < s2.top()){
        	s2.push(x);
        }else{
            s2.push(s2.top());
        }  
    }
 
    void pop() {
        s1.pop();
        s2.pop();
    } 
    
    int top() {
        return s1.top();
    }
    
    int min() {
        return s2.top();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->min();
 */

剑指 Offer 39. 数组中出现次数超过一半的数字

题目链接

题目描述：

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1:

输入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
输出: 2

限制：

1 <= 数组长度 <= 50000

思路：

法1：

将nums排序，超过一半的数字一定是中间的数字

时间：$O(nlogn)$，空间：$O(1)$

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        return nums[nums.size()/2];
    }
};

法2：

摩尔投票法：包括两个阶段

1、抵消阶段：两个不同投票进行对坑，并且同时抵消掉各一张票，如果两个投票相同，则累加可抵消的次数

2、计数阶段：在抵消阶段最后得到的抵消计数只要不为 0，则计算抵消阶段结果中最后留下的候选人票数是否有效

时间：$O(n)$，空间：$O(1)$

代码：

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int ans = 0,count = 0;
        for(int i = 0;i < nums.size();i++){
            if(count==0){
                ans = nums[i];
                count ++;
            }else{
                if(ans==nums[i]){
                    count ++;
                }else{
                    count --;
                }
            }
        }
        return ans;
    }
};