简单题

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        vector<int> vec1;
        vector<int> vec2;
        int size = array.size();
        for(int i  = 0; i < size;++i)
        {
            if(array[i] % 2 == 1)
                vec1.push_back(array[i]);
            else
                vec2.push_back(array[i]);
        }
        array.clear();
        int i = 0;
        while(i < vec1.size())
        {
            array.push_back(vec1[i]);
            i++;
        }
        i = 0;
        while(i < vec2.size())
        {
            array.push_back(vec2[i]);
            i++;
        }
    }
};

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {    
        if(pHead1 == nullptr && pHead2 == nullptr)
            return nullptr;
        if(pHead1 == nullptr)
            return pHead2;
        if(pHead2 == nullptr)
            return pHead1;
        ListNode* p1 = pHead1;
        ListNode* p2 = pHead2;
        ListNode* head = nullptr;
        ListNode* cur = nullptr;
        while(p1 != nullptr && p2 != nullptr)
        {
            if(head == nullptr)
            {
                if(p1->val  < p2->val)
                {
                    head = p1;
                    p1 = p1->next;
                }
                else
                {
                    head = p2;
                    p2 = p2->next;
                }
                cur = head;
            }
            else
            {
                if(p1->val  < p2->val)
                {
                    cur->next = p1;
                    cur = p1;
                    p1 = p1 -> next;
                }
                else
                {
                    cur->next = p2;
                    cur = p2;
                    p2 = p2->next;
                }
            }
        }
        if(p1 != nullptr)
        {
            cur->next =  p1;
        }
        if(p2 != nullptr)
        {
            cur->next =  p2;
        }
        return head;
    }
};

class Solution {
public:

	void push(int value) {
		vec1.push_back(value);
		if (vec2.size() == 0)
		{
			vec2.push_back(value);
		}
		else
		{
			if (value < vec2[size - 1])
				vec2.push_back(value);
			else
				vec2.push_back(vec2[size - 1]);
		}
		size++;
	}

	void pop() {
		/*vec1.erase(vec1.begin() + size - 1);
		vec2.erase(vec2.begin() + size - 1);*/
		vec1.erase(vec1.end() - 1);
		vec2.erase(vec2.end() - 1);
		size--;
	}
	int top() {
		return vec1[size - 1];
	}
	int min() {
		return vec2[size - 1];
	}
	vector<int> vec1;
	vector<int> vec2;
	int size = 0;
};

class Solution {
public:
    int cutRope(int number) {
        if(number <= 2)
            return 1;
        if(number == 4)
            return 4;
        if(number % 2 == 0)
            return ((number / 2) - 1) * ((number / 2) - 1) * (number - 2 *(number / 2) - 1);
        else 
            return (number / 2) * (number - (number / 2));
        
    }
};