Leetcode 刷题2

栈：先进后出的数据结构：在STL中有
S.top()
S.empty()
S.push(x)
S.pop()
S.size()

队列：先进先出的线性表：
Q.empty()
Q.front()
Q.back()
Q.pop()
Q.push(x)
Q.size()

第一题：使用队列实现栈：
实现一个栈，支持如下操作，这些操作的算法复杂度需要是常数级，O(1)，栈的内部存储数据的结构为队列，队列的方法只能包括push、peek(front)、pop、size、empty等标准的队列方法。
Leetcode 225
思路：我们使用一个临时队列temp_queue，push数据时，将数据push到临时队列里面，然后再将原来的数据push到临时队列中，最后再将所有的数据push到原来的队列中去。

queue<int> data;
void push(int x){
	queue<int> temp_queue;
	temp_queue.push(x);
	while(!data.empty()){
		temp_queue.push(data.front());
		data.pop();
	}
	while(!temp_queue.empty()){
		data.push(temp.front());
		temp_queue.pop();
	}
}
int pop()
{
		int x = data.front();
		data.pop();
		return x;
}
int top(){
	return data.front();
}
bool empty(){
	return data.empty();
}

第二题：使用栈实现队列 leetcode 232
设计一个队列，队列支持如下操作，这些操作的算法复杂度需要是常数级，O(1),队列的内部存储数据二代结构为栈，栈的方法只能包括push、top、pop、size、empty等标准的栈方法。
1.在队列push元素时，利用临时栈调换元素次序
2.将原数据栈内容push进入临时栈temp_stack
3.将新数据push进入临时栈temp_stack
4.将临时栈temp_stack的元素push进入数据栈data_stack

stack<int> data;
void push(int x){
	stack<int> temp_stack;
	while(!data.empty()){
		temp_stack.push(data.top());
		data.pop();
	}
	 temp_stack.push(x);
	 while(!temp.empty()){
		data.push(temp.top());
		temp.pop();
	}
}
int pop(){
	int x = data.top();
	data.pop();
	return x;
}
int peek(){
return data.top();
}
bool empty(){
 return data.empty();
}

第三题：包含min函数的栈 Leetcode 155
设计一个栈，支持如下操作，这些操作的算法复杂度需要是常数级，O(1)
push(x) pop() top() getMin()

思路：使用另一个栈，存储各个状态的最小值；

当最小值栈为空时，直接把数据压入栈中。当压入数据时，和栈顶进行比较，如果压入的数据比最小值栈顶的数据小，则压入最小值栈，否则压入栈顶的值。

stack<int> data;
stack<int> min;
void push(int x){
	data.push(x);
	if(min.empty())
		min.push(x);
	else {
		if(x>min.top())
			x= min.top();
		min.push(x);
	}
}
void pop(){
 data.pop();
 min.pop();
}
int top(){
 return data.top();
}
int getMin(){
 return min.top();
}

STL优先级队列：
priority queue big_heap; //默认构造最大堆
priority queue<int,vector,greater> small_heap; //最小堆构造方法
priority queue<int,vector,less> big_heap; //最大堆构造方法

第四题：数组中第K大的数leetcode 215
已知一个未排序的数组，求这个数组中第K大的数字
如 array = [3,2,1,5,6,4], k=2 return 5

思路：维护一个K大小的最小堆，堆中元素个数小于K时，新元素直接进入堆；否则，当堆顶小于新元素时，弹出堆顶，将新元素加入堆。由于堆是最小堆，堆顶是堆中最小元素，新元素都会保证比堆顶小(否则新元素替换堆顶)，故堆中K个元素是已扫描的元素里最大的K个；堆顶即为第K大的数。
设数组长度为N，求第K大的数，时间复杂度:N*logK

int findKthLargest(vector<int>& nums, int k){
	priority_queue<int vector<int>,greater<int>> Q;
	for(int i=0;i<nums.size();i++){
		if(Q.size()<k)
		   Q.push(nums[i]);
		 else if(Q.top<nums[i]){
			Q.pop();
			Q.push(nums[i]);
		}
	}
	return Q.top();
}