参考书本《程序员代码面试指南》
import java.util.Stack;
/**设计一个getMin功能的栈
【题目】实现一个特殊的栈,在实现栈的基本功能的基础上,再实现返回栈中最小元素的操作。
【要求】 1.pop、push、getMin操作的时间复杂度都是O(1)
2.设计的栈类型可以使用现成的栈结构。
【难度】*
**/
public class Mystack1 {
private Stack<Integer> stackData;
private Stack<Integer> stackMin;
public Mystack1(){
this.stackData = new Stack<Integer>();
this.stackMin = new Stack<Integer>();
}
//进栈操作,进行判断+对比:为空报错,不为空如果小于最小值的话还需要加紧stackMin中
public void push(int newNum){
if (this.stackData.isEmpty()){
this.stackMin.push(newNum);
}else if(newNum <= this.getmin()){
this.stackMin.push(newNum);
}
this.stackData.push(newNum);
}
//定义弹出操作,如果弹出值是最小值的话还需要将最小值栈给弹出
public int pop(){
if (this.stackData.isEmpty()){
throw new RuntimeException("stack is empty.");
}
int value = this.stackData.pop();
if (value == this.getmin()){
this.stackMin.pop();
}
return value;
}
//定义getmin函数获取最小值,时间复杂度为O(1)
private int getmin() {
if(this.stackMin.isEmpty()){
throw new RuntimeException("Your stack is empty.");
}
return this.stackMin.peek();
}
}
解法2:
import java.util.Stack;
public class Mystack2 {
private Stack<Integer> stackData;
private Stack<Integer> stackMin;
public Mystack2(){
this.stackData = new Stack<Integer>();
this.stackMin = new Stack<Integer>();
}
public void push(int newNum){
if(stackMin.isEmpty()){
this.stackMin.push(newNum);
}else if(newNum < stackMin.peek()){
this.stackMin.push(newNum);
}else{
int min = this.stackMin.peek();
this.stackMin.push(min);
}
this.stackData.push(newNum);
}
public int pop(){
if(this.stackData.isEmpty()){
throw new RuntimeException("your stack is empty!");
}else{
this.stackMin.pop();
return this.stackData.pop();
}
}
public int getMin(){
if (this.stackData.isEmpty()){
throw new RuntimeException("this stack is empty!");
}
return this.stackMin.peek();
}
}
题目3:
package 第一章;
import java.util.Stack;
/**
* 【题目】
* 编写一个类,用两个栈实现队列的操作,支持队列的基本操作(add添加,poll头部弹出(且删除),peek查看首元素)
* 【难度】**
* 【解题】
* 定义两个栈,stackPush和stackPop,一个负责进队列,一个负责出队列,。
*
*/
public class TwoStackQueue {
public Stack<Integer> stackPush;
public Stack<Integer> stackPop;
public TwoStackQueue(){
stackPush = new Stack<Integer>();
stackPop = new Stack<Integer>();
}
//push栈向pop栈倒入数据
private void pushToPop(){
if (stackPop.isEmpty()){
while (!stackPush.isEmpty()){
stackPop.push(stackPush.pop());
}
}
}
//add操作,将数据存入stackPush栈
public void add(int newNum){
stackPush.push(newNum);
pushToPop();
}
//poll操作,将元素从pop栈中弹出并删除
public int poll(){
if (stackPop.isEmpty() && stackPush.isEmpty()){
throw new RuntimeException("stack is empty!");
}
pushToPop();
return stackPop.pop();
}
//peek查看队列头元素
public int peek(){
if (stackPop.isEmpty() && stackPush.isEmpty()){
throw new RuntimeException("stack is empty!");
}
pushToPop();
return stackPop.peek();
}
}
/**
测试类
**/
class TwoStackQueueTest{
public static void main(String[] args) {
TwoStackQueue twoStackQueue = new TwoStackQueue();
//add方法
twoStackQueue.add(1);
twoStackQueue.add(2);
twoStackQueue.add(3);
twoStackQueue.add(4);
twoStackQueue.add(5);
//poll方法
int poll = twoStackQueue.poll();
System.out.println(poll);
//peek查看元素
int peek = twoStackQueue.peek();
System.out.println(peek);
}
}
题目4:
package 第一章;
import java.util.Stack;
/**
* 【题目】
* 一个栈依次压入1、2、3、4、5,那么从栈顶到栈底分别为5、4、3、2、1.
* 将这个栈转职,从栈顶到栈底分别为1、2、3、4、5,也就是实现栈中元素的逆序,
* 但智能用递归函数实现,不能用其他数据结构
* 【难度】**
* 【思路】
* 通过两个递归甘薯解决
*/
public class getAndRemovelastElement3 {
//递归函数1:将栈stack的栈底元素返回并移除
public int getAndRemoveLastElement(Stack<Integer> stack){
int result = stack.pop();
if (stack.isEmpty()){
return result;
}else{
int last = getAndRemoveLastElement(stack);
stack.push(result);
return last;
}
}
//递归函数2:逆序一个栈,结合上面的递归函数1实现
public void reverse(Stack<Integer> stack){
if (stack.isEmpty()){
return;
}
int i = getAndRemoveLastElement(stack);
reverse(stack);
stack.push(i);
}
}