java实现栈的两种存储

一、栈的顺序存储结构实现

利用一组地址连续的存储单元依次存放栈中的元素，基于数组形式实现，根据数组操作的特性，选择数组下标大的一端作为栈顶。

此时入栈和出栈操作都在o(1)时间内完成。

栈的顺序存储基本模型：

package stack;
/**
 * 栈的顺序存储实现模型：基于数组实现栈的操作，访问元素受限，每次只能访问最顶端的元素;
 * 指针top动态指向栈顶元素的位置，top=-1时空栈;
 * 实现要求：随意的输入字符串或数组能够实现相关操作
 * @author USER
 *
 */
public class StackArray {
	private int top;//栈顶指针
	private int maxSize;//栈的大小
	private char[] data;//栈元素
	
	//栈的构造函数，指定接收外界传入的元素个数、指针初始化、新建指定大小的数组
	public StackArray(int size){
		maxSize = size;
		data = new char[maxSize];
		top = -1;
	}
	
	//入栈
	public void push(char value) {
		data[++top] = value;
	}
	//出栈
	public char pop() {
		return data[top--];
	}
	//查看栈顶元素
	public char peek() {
		return data[top];
	}
	//栈是否为空
	public boolean isEmpty() {
		return top == -1;
	}
	//栈是否已满
	public boolean isFull() {
		return top == maxSize-1;
	}
	//返回栈的大小
	public int length() {
		return maxSize;
	}
}

通过这个模型实现一个应用：一串字符或数字的逆序输出

package stack;

import java.util.Scanner;

/**
 * 实现一串字符或数字的逆序排列
 * @author USER
 *
 */

public class StackArrayApp {
	public static void main(String[] args) {
		System.out.print("输入一串字符或数字:");
		Scanner in = new Scanner(System.in);
		String string = in.next();
		
		int len = string.length();
		StackArray stack = new StackArray(len);
		for (int i = 0; i < len; i++) {
			stack.push(string.charAt(i));
		}
		
/*		System.out.println(stack.peek());
		System.out.println(stack.isFull());
		System.out.println(stack.length());*/
		
		String output = "";
		while (!stack.isEmpty()) {
			char ch = stack.pop();
			output = output + ch;
		}
		
		System.out.println("逆序输出为:"+output);
	}
}

当然这个逆序输出有个更简单的方法实现：

package stack;
/**
 * 实现一串字符或数字的逆序输出
 */
import java.util.Scanner;

public class WordReverse1 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		String string = input.next();
		
		int size = string.length();
		String output = "";
		for (int i = size-1; i >= 0; i--) {
			char ch = string.charAt(i);
			output = output+ch;
		}
		System.out.print(output);
	}
}

二、栈的链式存储结构实现

采用单链表结构实现存储，由于栈的操作只能在单链表的一端进行，所以选择不带头结点的单链表，插入和删除结点元素都在当前结点进行。

栈的链式存储基本模型：

package stack;
/**
 * 栈的链式存储模型:基于链表作为存储结构实现的，本例通过单链表实现；
 * 指针top为链表结点引用，始终指向栈顶元素所在的结点；
 * @author USER
 *
 */
//节点类
class SLnode{
	private String data;
	private SLnode next;
	
	public SLnode(SLnode next, String data) {
		this.next = next;
		this.data = data;
	}

	public String getData() {
		return data;
	}

	public SLnode getNext() {
		return next;
	}
}

//单链表实现的栈类
public class StackLink {
	private SLnode top;
	private int size;
	
	public StackLink() {
		top = null;
		size = 0;
	}
	
	//入栈
	public void push(String str) {
		SLnode p = new SLnode(top, str);//新入栈的结点p的next域指向top
		top = p;
		size++;
	}
	
	//出栈
	public String pop() {
		String ch = top.getData();
		top = top.getNext();
		size--;
		return ch;
	}
	
	//查看栈顶结点元素
	public String peek() {
		return top.getData();
	}
	
	//栈是否为空
	public boolean isEmpty() {
		return size == 0;
	}
	
	//返回栈的大小
	public int getSize() {
		return size;
	}
}

通过这个模型实现一个应用：进制数的转换，十进制数转换为八进制

package stack;

import java.util.Scanner;

/**
 * 实现进制的转换：本例是输入一个10进制的数，转换为8进制；
 * 如：十进制2007->八进制3727；通过2007对8求余，求出的余数按后出现先输出
 * @author USER
 *
 */
public class StackLinkApp {
	public static void main(String[] args) {
		System.out.print("输入一个正整数:");
		Scanner in = new Scanner(System.in);
		int a = in.nextInt();
		StackLink stackLink = new StackLink();
		while (a>0) {
			stackLink.push(a%8+"");//对8取余数，并转化为字符串形式
			a = a/8;
		}
		while (!stackLink.isEmpty()) {
			System.out.print(stackLink.pop());
		}
	}
}