栈是临时的数据结构,存储容量很小。遵循后进先出原则(LIFO),栈只允许访问一个数据项:即最后插入的数据项。只有移除这个数据项后才能访问倒数第二个插入的数据项,依此类推。
插入:栈的指针永远指向栈元素,即指向最后插入的元素。当插入数据时,指针会上移一个单元,然后将数据插入至该存储单元。
删除:移除最后插入的栈顶元素,然后指针下移指向新的栈顶元素。栈中被删除的数据还存留在其中,直到被新的数据项覆盖为止,但该项被删除后不能被访问。
查看:只能查看栈顶元素,即最后插入的数据项。
class StackX {
private int maxSize;
private long[] stackArray;
private int top;
public StackX(int s) {
maxSize = s;
stackArray = new long[maxSize];
top = -1;
}
public void push(long j) {
stackArray[++top] = j
}
public long pop() {
return stackArray[top--];
}
public long peek() {
return stackArray[top];
}
public boolean isEmpty() {
return (top == -1);
}
public boolean isFull() {
return (top == maxSize - 1);
}
}
class StackApp {
public static void main(String[] args) {
StackX theStack = new StackX(10);
theStack.push(20);
theStack.push(40);
theStack.push(60);
theStack.push(80);
while(!theStack.isEmpty()) {
long value = theStack.pop();
System.out.println(value);
System.out.println(" ");
}
System.out.println("");
}
}
实现字符串分隔符匹配栈运用代码示例:
class StackX {
private int maxSize;
private long[] stackArray;
private int top;
public StackX(int s) {
maxSize = s;
stackArray = new long[maxSize];
top = -1;
}
public void push(long j) {
stackArray[++top] = j
}
public long pop() {
return stackArray[top--];
}
public long peek() {
return stackArray[top];
}
public boolean isEmpty() {
return (top == -1);
}
public boolean isFull() {
return (top == maxSize - 1);
}
}
class BracketChecker {
private String input;
public BracketChecker(String input) {
this.input = input;
}
public void check() {
int stackSize = input.length();
StackX theStack = new StackX(stackSize);
for(int j = 0; j < input.length(); j++) {
char ch = input.charAt(j);
switch(ch) {
case '{':
case '[':
case '(':
theStack.push(ch);
break;
case '}':
case ']':
case ')':
if (!theStack.isEmpty()) {
char chx = theStack.pop();
if ((ch == '}' && chx != '{') ||
(ch == ']' && chx != '[') ||
(ch == ')' && chx != '('))
{
System.out.println("Error: " + ch + " at " + j);
}
} else {
System.out.println("Error: " + ch + " at " + j);
}
break;
default:
break;
}
}
if (!theStack.isEmpty()) {
System.out.println("Error: missing right delimiter");
}
}
}
class BracketsApp {
public static void main(String[] args) throws IOException {
String input;
while(true) {
System.out.println("Enter string containing delimiters: ");
System.out.flush();
input = getString();
if (input.equals("")) {
break;
}
BracketChecker theChecker = new BracketChecker(input);
theChecker.check();
}
}
public static String getString() throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}
}
StackX类中实现的栈,数据项入栈和出栈的时间复杂度均为常数O(1),即栈操作所耗的时间不依赖于栈中数据项的个数,栈不需要比较和移动操作,因此操作时间很短。
队列遵循先进先出原则(FIFO),队列和栈一样,插入数据项和移除数据项的时间复杂度均为O(1)。
队列的Java代码:
class Queue {
private int maxSize;
private long[] queArray;
private int front;
private int rear;
private int nItems;
public Queue(int s) {
maxSize = s;
queArray = new long[maxSize];
front = 0;
rear = -1;
nItems = 0;
}
public void insert(long j) {
if (rear == maxSize - 1) {
rear = -1;
}
queArray[++rear] = j;
nItems++;
}
public void remove() {
long temp = queArray[front++];
if (front == maxSize) {
front = 0;
}
nItems--;
return temp;
}
public long peekFront() {
return queArray[front];
}
public boolean isEmpty() {
return (nItems == 0);
}
public boolean isFull() {
return(nItems == maxSize);
}
public int size() {
return nItems;
}
}
class QueueApp {
public static void main(String[] args) {
Queue theQueue = new Queue(5);
theQueue.insert(10);
theQueue.insert(20);
theQueue.insert(30);
theQueue.insert(40);
theQueue.remove();
theQueue.remove();
theQueue.remove();
theQueue.insert(50);
theQueue.insert(60);
theQueue.insert(70);
theQueue.insert(80);
while(!theQueue.isEmpty()) {
long n = theQueue.remove();
System.out.print(n);
System.out.print(" ");
}
System.out.println("");
}
}
class Queue {
private int maxSize;
private long[] queArray;
private int front;
private int rear;
public Queue(int s) {
maxSize = s + 1;
queArray = new long[maxSize];
front = 0;
rear = -1;
}
public void insert(long j) {
if (rear == maxSize - 1) {
rear = -1;
}
queArray[++rear] = j;
}
public long remove() {
long temp = queArray[front++];
if (front == maxSize) {
front = 0;
}
return temp;
}
public long peek() {
return queArray[front];
}
public boolean isEmpty() {
return (rear + 1 == front || (front + maxSize - 1 == rear));
}
public boolean isFull() {
return(rear + 2 == front || (front + maxSize - 2 == rear);
}
public int size() {
if (rear >= front)
return rear - front + 1;
else
return (maxSize - front) + (rear + 1);
}
}
class QueueApp {
public static void main(String[] args) {
Queue theQueue = new Queue(5);
theQueue.insert(10);
theQueue.insert(20);
theQueue.insert(30);
theQueue.insert(40);
theQueue.remove();
theQueue.remove();
theQueue.remove();
theQueue.insert(50);
theQueue.insert(60);
theQueue.insert(70);
theQueue.insert(80);
while(!theQueue.isEmpty()) {
long n = theQueue.remove();
System.out.print(n);
System.out.print(" ");
}
System.out.println("");
}
}
注:双端队列就是一个两端都是结尾的队列。队列的每一端都可以插入数据和移除数据。