剑指 Offer 刷题

 

 

 

 

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

暴力，数组另存

先遍历奇数放入数组,再遍历偶数放入数组

class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        vector<int>odd;
        vector<int>even;
        vector<int>result;
        for(int i=0;i<nums.size();i++)
        {
            if((nums[i]&1)==1)
            {
                odd.push_back(nums[i]);
            }
            else
            {
                even.push_back(nums[i]);
            }
        }
        for(int i=0;i<odd.size();i++)
        {
            result.push_back(odd[i]);
        }
        for(int i=0;i<even.size();i++)
        {
            result.push_back(even[i]);
        }
        return result;
    }
};

首尾双指针

• 定义头指针 left，尾指针 right .
• left 一直往右移，直到它指向的值为偶数
• right 一直往左移， 直到它指向的值为奇数
• 交换 nums[left] 和 nums[right] .
• 重复上述操作，直到 left == right.

class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        int findeven=0;
        int findodd=nums.size()-1;
        while(findeven<findodd)
        {
            if((nums[findeven]&1)==1)
            {
                findeven++;
                continue;
            }
            if((nums[findodd]&1)==0)
            {
                findodd--;
                continue;
            }
            int temp=nums[findeven];
            nums[findeven]=nums[findodd];
            nums[findodd]=temp;
            findeven++;
            findodd--;
        }
        return nums;
    }
};

 

 

 

 

 

面试题30. 包含min函数的栈

辅助栈

class MinStack {
public:
    stack<int>s;
    stack<int>mins;
    /** initialize your data structure here. */
    MinStack() {
        mins.push(INT_MAX);
    }
    
    void push(int x) {
        s.push(x);
        if(mins.top()>=x)
        {
            mins.push(x);
        }
        else
        {
            mins.push(mins.top());
        }
    }
    
    void pop() {
        s.pop();
        mins.pop();
    }
    
    int top() {
        return s.top();
    }
    
    int min() {
        return mins.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 59 - II. 队列的最大值

维护单调的双向队列

从队列尾部插入元素时，我们可以提前取出队列中所有比这个元素小的元素，使得队列中只保留对结果有影响的数字。这样的方法等价于要求维持队列单调递减，即要保证每个元素的前面都没有比它小的元素。

需要从队列尾部取出元素，因此需要使用双端队列来实现

class MaxQueue {
public:
    deque<int>fuzhuq;
    queue<int>q;
    MaxQueue() {

    }
    
    int max_value() {
        if(fuzhuq.empty())return -1;
        return fuzhuq.front();
    }
    
    void push_back(int value) {
        q.push(value);
        if(fuzhuq.empty())
        {
            fuzhuq.push_back(value);
            return;
        }
        if(fuzhuq.back()>=value)
        {
            fuzhuq.push_back(value);
        }
        else
        {
            while(!fuzhuq.empty() && fuzhuq.back()<value)
            {
                fuzhuq.pop_back();
            }
            fuzhuq.push_back(value);
        }
    }
    
    int pop_front() {
        if(q.empty())return -1;
        int temp=q.front();
        if(q.front()==fuzhuq.front())
        {
            fuzhuq.pop_front();
        }
        q.pop();
        return temp;
    }
};

/**
 * Your MaxQueue object will be instantiated and called as such:
 * MaxQueue* obj = new MaxQueue();
 * int param_1 = obj->max_value();
 * obj->push_back(value);
 * int param_3 = obj->pop_front();
 */