括号匹配问题
public static boolean isValid(String s) {
Stack<Character> stack = new Stack<>();
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
if (ch == '(' || ch == '[' || ch == '{') {
stack.push(ch);
}else {
//1、判断栈是否为空
if (stack.empty()) {
System.out.println("右括号多!");
return false;
}
//先拿到栈顶元素的括号
char ch2 = stack.peek();
if (ch2 == '(' && ch == ')' || ch2 == '[' && ch == ']' || ch2 == '{' && ch == '}') {
stack.pop();
}else {
System.out.println("左右括号不匹配");
return false;
}
}
}
if (!stack.empty()) {
System.out.println("左括号多!");
return false;
}
return true;
}
用队列实现栈
public class MyStack {
private Queue<Integer> queue1;
private Queue<Integer> queue2;
public MyStack() {
queue1 = new LinkedList<>();
queue2 = new LinkedList<>();
}
public void push(int x) {
if (this.queue1 == null && this.queue2 == null) {
queue1.add(x);
return;
}
if (queue1 != null) {
queue1.add(x);
return;
}
if (queue2 != null) {
queue2.add(x);
return;
}
}
public int pop() {
if (empty()) {
return -1;
}
int qSize1 = queue1.size();
int qSize2 = queue2.size();
int data = 0;
if (!queue1.isEmpty()) {
for (int i = 0; i < qSize1-1; i++) {
queue2.offer(queue1.poll());
}
data = queue1.poll();
}else {
for (int i = 0; i < qSize2-1; i++) {
queue1.offer(queue2.poll());
}
data = queue2.poll();
}
return data;
}
public int top() {
if (empty()) {
return -1;
}
int qSize1 = queue1.size();
int qSize2 = queue2.size();
int data = 0;
if (!queue1.isEmpty()) {
for (int i = 0; i < qSize1; i++) {
data = queue1.poll();
queue2.offer(data);
}
}else {
for (int i = 0; i < qSize2; i++) {
data = queue2.poll();
queue1.offer(data);
}
}
return data;
}
private boolean empty() {
if (queue1.isEmpty() && queue2.isEmpty()) {
return true;
}
return false;
}
}
用栈实现队列
public class MyQueue {
private Stack<Integer> stack1;
private Stack<Integer> stack2;
public MyQueue() {
stack1 = new Stack<>();
stack2 = new Stack<>();
}
public void push(int x) {
stack1.push(x);
}
public int pop() {
if (empty()) {
return -1;
}
if (stack2.empty()) {
while (!stack1.empty()) {
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
public int peek() {
if (empty()) {
return -1;
}
if (stack2.empty()) {
while (!stack1.empty()) {
stack2.push(stack1.pop());
}
}
return stack2.peek();
}
private boolean empty() {
if (stack1.empty() && stack2.empty()) {
return true;
}
return false;
}
}
实现一个最小栈
public class MinStack {
private Stack<Integer> stack;
private Stack<Integer> minStack;
public MinStack() {
this.stack = new Stack<>();
this.minStack = new Stack<>();
}
public void push(int x) {
stack.push(x);
if (minStack.empty()) {
//最小栈内没有元素
minStack.push(x);
}else {
//最小栈内有元素 拿到栈顶元素 和x比较
int top = minStack.peek();
if (x <= top) {
minStack.push(x);
}
}
}
public void pop() {
if (!stack.empty()) {
int tmp = stack.pop();
if (tmp == minStack.peek()) {
minStack.pop();
}
}
}
public int top() {
if (!stack.empty()) {
return -1;
}
return stack.peek();
}
public int getMin() {
if (!minStack.empty()) {
return -1;
}
return minStack.peek();
}
}
设计循环队列
public class MyCircularQueue {
public int[] elem;
public int front;
public int rear;
public MyCircularQueue(int k) {
this.elem = new int[k];
}
public boolean enQueue(int value) {
if (isFull()) {
return false;
}
this.elem[this.rear] = value;
this.rear = (this.rear+1)%this.elem.length;
return true;
}
public boolean deQueue() {
if (isEmpty()) {
return false;
}
this.front = (this.front+1)%this.elem.length;
return true;
}
public int Front() {
if (isEmpty()) {
return -1;
}
return this.elem[this.front];
}
public int Rear() {
if (isEmpty()) {
return -1;
}
int index = this.rear == 0 ? this.elem.length-1 : this.rear-1;
return this.elem[index];
}
public boolean isEmpty() {
return this.rear == this.front;
}
public boolean isFull() {
if ((this.rear+1)%this.elem.length == this.front) {
return true;
}
return false;
}
}