队列，栈
队列（FIFO）
先进先出
数组实现
判断实现
public class MyCircularQueue02 {
private int[] data;
private int head;
private int tail;
private int size;
public MyCircularQueue02(int k) {
data = new int[k];
head = -1;
tail = -1;
size = k;
}
public boolean enQueue(int value) {
if (isFull() == true) {
return false;
}
if (isEmpty() == true) {
head = 0;
}
tail = (tail + 1) % size;
data[tail] = value;
return true;
}
public boolean deQueue() {
if (isEmpty() == true) {
return false;
}
if (head == tail) {
head = -1;
tail = -1;
return true;
}
head = (head + 1) % size;
return true;
}
public int Front() {
if (isEmpty() == true) {
return -1;
}
return data[head];
}
public int Rear() {
if (isEmpty() == true) {
return -1;
}
return data[tail];
}
public boolean isEmpty() {
return head == -1;
}
public boolean isFull() {
return ((tail + 1) % size) == head;
}
}
采用 牺牲一个空间实现
public class MyCircularQueue01 {
private int[] data;
private int head;
private int tail;
private int size;
public MyCircularQueue01(int size) {
this.size = size;
data = new int[size + 1];
head = 0;
tail = 0;
}
public boolean enQueue(int value) {
if (isFull()) {
return false;
}
data[tail] = value;
tail = (tail+1)%data.length;
return true;
}
public boolean deQueue() {
if (isEmpty()) {
return false;
}
int pop = data[head];
head = (head+1)%data.length;
return true;
}
public boolean isEmpty() {
return head == tail;
}
public boolean isFull() {
return (tail + 1) % data.length == head;
}
/** Get the front item from the queue. */
public int Front() {
if (isEmpty()) {
return -1;
}
return data[head];
}
/** Get the last item from the queue. */
public int Rear() {
if (isEmpty()) {
return -1;
}
return data[tail];
}
}
链表实现
public class Queue<Item> implements Iterable<Item> {
private Node first; //指向头
private Node last;//指向最近添加的元素
private int N;//元素个数
private class Node {
Item item;
Node next;
}
public boolean isEmpty() {
return first == null;
}
public int size() {
return N;
}
public void enqueue(Item item) {
//添加到队列末尾
Node oldlast = last;
last = new Node();
last.item = item;
last.next = null;
if (isEmpty()) {
first = last;
} else {
//队列不为空，添加到末尾节点后面
oldlast.next = last;
}
N++;
}
public Item dequeue() {
Item item = first.item;
first = first.next;
if (isEmpty()) {
last = null;
}
N--;
return item;
}
public Iterator<Item> iterator() {
return new listIterator();
}
public class listIterator implements Iterator<Item> {
private Node current = first;
@Override
public boolean hasNext() {
return current != null;
}
@Override
public Item next() {
Item item = current.item;
current = current.next;
return item;
}
}
}
栈
后进先出
数组实现
public class ResizingArrayStack<Item> implements Iterable<Item>{
private Item[] a;
private int N;
public ResizingArrayStack() {
a = (Item[]) new Object[1];
}
public ResizingArrayStack(int cap) {
a = (Item[]) new Object[cap];
}
public boolean isEmpty() {
return N == 0;
}
public void push(Item item) {
if (N == a.length) {
resize(2 * a.length);
}
a[N++] = item;
}
public Item pop() {
Item item = a[--N];
// 处理对象游离
a[N] = null;
//数组太大减半
//当数组长度小于1/4时，长度减半后，状态刚好半满
if (N > 0 && N == a.length / 4) {
resize(a.length / 2);
}
return item;
}
//调整数组大小
public void resize(int max) {
Item[] temp = (Item[]) new Object[max];
for (int i = 0; i < N; i++) {
temp[i] = a[i];
}
a = temp;
}
@Override
public Iterator<Item> iterator() {
return null;
}
private class ReverseArrayIterator implements Iterator<Item> {
private int i = N;
@Override
public boolean hasNext() {
return i > 0;
}
@Override
public Item next() {
return a[i--];
}
}
}
链表实现
public class Stack<Item> implements Iterable<Item> {
private class Node {
Item item;
Node next;
}
private Node first;//栈顶
private int N;//元素数量
public boolean isEmpty() {
return first == null;
}
public int size() {
return N;
}
public void push(Item item) {
Node oldfirst = first;
first = new Node();//new 一个新节点放到表头
first.item = item;
first.next = oldfirst;
N++;
}
public Item pop() {
Item item = first.item;
first = first.next;
N--;
return item;
}
public Iterator<Item> iterator() {
return new listIterator();
}
public class listIterator implements Iterator<Item> {
private Node current = first;
@Override
public boolean hasNext() {
return current != null;
}
@Override
public Item next() {
Item item = current.item;
current = current.next;
return item;
}
}
}
应用
算法表达式求值
求((1+2)*3)表达式的值
public class Evaluate {
public static double compute(String s) {
Stack<String> ops = new Stack<>();
Stack<Double> vals = new Stack<>();
for (char c : s.toCharArray()) {
if (c == '(') {
} else if (c == '+') {
ops.push("+");
} else if (c == '-') {
ops.push("-");
} else if (c == '*') {
ops.push("*");
} else if (c == '/') {
ops.push("/");
} else if (c == ')') {
String op = ops.pop();
Double v = vals.pop();
if (op == "+") {
v = vals.pop() + v;
}
if (op == "-") {
v = vals.pop() - v;
}
if (op == "*") {
v = vals.pop() * v;
}
if (op == "/") {
v = vals.pop() / v;
}
vals.push(v);
} else {
vals.push(Double.valueOf(String.valueOf(c)));
}
}
return vals.pop();
}
public static void main(String[] args) {
double v = compute("((1+2)*3)");
System.out.println(v);
}
}
