Stack栈的基本操作:
new Stack():创建一个空栈
push(E e):将元素压入栈,返回值为该元素
pop():将元素弹出栈,返回值为该元素
peek():返回栈顶元素,但是并不从栈中移除该元素
empty():测试栈是否为空,返回boolean值
可查询最值的栈问题
题目:
定义栈的数据结构,请在该类型中实现一个能够得到栈最小元素的min函数。
代码:
import java.util.Stack;
public class Solution {
//定义两个栈结构,一个存储数据,一个存储最小值
Stack<Integer> stackData = new Stack<Integer>();
Stack<Integer> stackMin = new Stack<Integer>();
//压入操作
public void push(int node) {
//数据栈直接压入
stackData.push(node);
//最小值栈做判断:是否为空,为空可以直接压入,不为空的情况需要比较当前元素与最小值栈栈顶元素值的大小
if(!stackMin.empty()){
if(stackMin.peek()<=node){
stackMin.push(stackMin.peek());
}else{
stackMin.push(node);
}
}else{
stackMin.push(node);
}
}
//弹出操作
public void pop() {
if(stackData.empty()){
throw new RuntimeException("Stack is empty");
}else{
stackData.pop();
stackMin.pop();
}
}
//获取栈顶元素
public int top() {
if(stackData.empty()){
throw new RuntimeException("Stack is empty");
}else{
return stackData.peek();
}
}
//获取最小元素
public int min() {
if(stackMin.empty()){
throw new RuntimeException("Stack is empty");
}else{
return stackMin.peek();
}
}
}
双栈队列问题
题目:
编写一个类,只能用两个栈结构实现队列,支持队列的基本操作(push,pop)。
给定一个操作序列ope及它的长度n,其中元素为正数代表push操作,为0代表pop操作,保证操作序列合法且一定含pop操作,请返回pop的结果序列。
测试样例:
[1,2,3,0,4,0],6
返回:[1,2]
代码:
import java.util.*;
public class TwoStack {
//定义两个栈,分别用于压入数据与弹出数据,模拟入队与出队
Stack<Integer> stackPush = new Stack<Integer>();
Stack<Integer> stackPop = new Stack<Integer>();
public int[] twoStack(int[] ope, int n) {
//循环数组执行操作
int count = 0;
for(int i=0;i<n;i++){
if(ope[i]==0){
count++;
}
}
int[] result = new int[count];
int j= 0;
for(int i=0;i<n;i++){
if(ope[i]!=0){
push(ope[i]);
}else{
result[j++] = pop();
}
}
return result;
}
public void push(int node){
stackPush.push(node);
}
//保证两点:
//每次倒入数据时stackPop栈中为空
//stackPush倒数据的时候要一次性倒完
public int pop(){
if(stackPop.empty()&&stackPush.empty()){
throw new RuntimeException("Queue is empty");
}
if(stackPop.empty()){
while(!stackPush.empty()){
stackPop.push(stackPush.pop());
}
}
return stackPop.pop();
}
}
栈的反转
题目:
实现一个栈的逆序,但是只能用递归函数和这个栈本身的pop操作来实现,而不能自己申请另外的数据结构。
给定一个整数数组A即为给定的栈,同时给定它的大小n,请返回逆序后的栈。
测试样例:
[4,3,2,1],4
返回:[1,2,3,4]
代码:
import java.util.*;
public class StackReverse {
public int[] reverseStack(int[] A, int n) {
//边界条件判定
if(A==null||n==0){
return null;
}
Stack<Integer> stack = new Stack<Integer>();
//数组转栈
for(int i=n-1;i>=0;i--){
stack.push(A[i]);
}
reverse(stack);
int j = 0;
//栈转为数组
while(!stack.empty()){
A[j++] = stack.pop();
}
return A;
}
//逆序方法
public void reverse(Stack<Integer> stack){
//栈为空,直接返回
if(stack.empty()){
return;
}
//递归去除栈底元素,并重新压入
int last = get(stack);
reverse(stack);
stack.push(last);
}
//返回栈底元素并删除
public int get(Stack<Integer> stack){
//弹出栈顶元素
int result = stack.pop();
//判断,如果此时为空,则上一步弹出的即为栈底元素
if(stack.empty()){
return result;
}else{
//last表示栈底元素
int last = get(stack);
//非栈底元素重新按照顺序压入栈中
stack.push(result);
return last;
}
}
}
双栈排序问题
题目:
请编写一个程序,按升序对栈进行排序(即最大元素位于栈顶),要求最多只能使用一个额外的栈存放临时数据,但不得将元素复制到别的数据结构中。
给定一个int[] numbers(C++中为vector<int>),其中第一个元素为栈顶,请返回排序后的栈。请注意这是一个栈,意味着排序过程中你只能访问到第一个元素。
测试样例:
[1,2,3,4,5]
返回:[5,4,3,2,1]
代码:
import java.util.*;
public class TwoStacks {
public ArrayList<Integer> twoStacksSort(int[] numbers) {
//边界条件判定
if(numbers==null||numbers.length==0){
return null;
}
//定义临时栈,在临时栈中排序
Stack<Integer> helpStack = new Stack<Integer>();
//变量i代表当前栈顶
int i = 0;
int temp = 0;
while(i<numbers.length){
//如果临时栈为空,直接压入数据
if(helpStack.empty()){
helpStack.push(numbers[i]);
i++;
}else{
//不为空的情况要进行比较,比较当前栈顶元素与临时栈顶元素的大小,
//临时栈顶元素较小或等于的话直接压入数据
//否则要先把临时栈中小于当前栈顶元素的元素先弹出,然后再压入当前栈顶元素,后续循环一样的步骤
temp = numbers[i];
i++;
while(helpStack.peek()>temp){
numbers[--i] = helpStack.pop();
//有可能helpStack为空了,循环条件peek()会报错,所以这里检查一下,为空则跳出循环即可
if(helpStack.empty()){
break;
}
}
helpStack.push(temp);
}
}
ArrayList<Integer> list = new ArrayList<Integer>();
while(!helpStack.empty()){
list.add(helpStack.pop());
}
return list;
}
}
滑动窗口问题
题目:
有一个整型数组 arr 和一个大小为 w 的窗口从数组的最左边滑到最右边,窗口每次向右边滑一个位置。 返回一个长度为n-w+1的数组res,res[i]表示每一种窗口状态下的最大值。 以数组为[4,3,5,4,3,3,6,7],w=3为例。因为第一个窗口[4,3,5]的最大值为5,第二个窗口[3,5,4]的最大值为5,第三个窗口[5,4,3]的最大值为5。第四个窗口[4,3,3]的最大值为4。第五个窗口[3,3,6]的最大值为6。第六个窗口[3,6,7]的最大值为7。所以最终返回[5,5,5,4,6,7]。
给定整形数组arr及它的大小n,同时给定w,请返回res数组。保证w小于等于n,同时保证数组大小小于等于500。
测试样例:
[4,3,5,4,3,3,6,7],8,3
返回:[5,5,5,4,6,7]
解体思路:核心思想构建一个双端队列,里面维护着每一次窗口滑动的最大值所对应的下标。
代码:
import java.util.*;
public class SlideWindow {
public int[] slide(int[] arr, int n, int w) {
//边界条件判定
if(arr==null||w<=0){
return null;
}
//构建双端队列,存储滑动窗口的最大值
LinkedList<Integer> queue = new LinkedList<Integer>();
//创建结果数组
int[] result = new int[n-w+1];
//创建结果数组递增下标
int index = 0;
//遍历循环数组
for(int i=0;i<n;i++){
//如果双端队列不为空,且当前窗口最新进入的值大于队列队尾的值,则删除队尾值,循环检查
while(!queue.isEmpty()&&arr[queue.peekLast()]<=arr[i]){
queue.pollLast();
}
//加入队尾
queue.addLast(i);
//队头的下标是否过期,过期就剔除
if(queue.peekFirst()==(i-w)){
queue.pollFirst();
}
//以此插入最大值
if(i>=w-1){
result[index++] = arr[queue.peekFirst()];
}
}
return result;
}
}