Java设计和实现栈

        众所周知，栈是在编程中很常用的一种数据结构，栈的特点是后进先出，本文整理了Java中堆栈实现的几种方法。

        栈中主要的方法：

                Push：入栈操作，将数据加到栈顶；

                Pop：出栈操作，返回栈顶数据；

                GitSize：返回栈规模；

                empty：判断栈是否为空

1.用数组实现栈（顺序栈）：

        用数组实现栈的方法十分简单，代码如下：

        

public class Stack_Array {    
	private int[] array = new int[10];
	private int longest = 10;
	private int size = 0;//用于存储栈规模以及栈顶位置
	
	public void Push(int a) {//入栈
	    if(size<longest) {
	        array[size] = a;
	        size++;
	    }
	    else {
	        System.out.println("栈已满。");
	    }
	}
	public int Pop() {//出栈
	    if(size>0) {
	        size--;
	        return array[size];
	    }
	    else {
	        System.out.println("栈为空");
	        return 0;
	        }
	    }
	    int GetSize() {//获取栈规模
	        return size;
	    } 
	public boolean empt(){ //判断栈是否为空
		return size == 0; 
		}
}

        但是，显而易见的是，上面这种方法实现的栈总规模有限，在存储较多数据时会有栈空间不够用的情况，一次分配较多空间的话，又会造成大量空间的浪费。所以我们对其进行适当的改进，使其可以自适应地调整数组大小，以此来保证能存下较多数据的同时对存储空间有较好的利用。改进后的代码如下：

public class Stack_Array {
	private int[] array = new int[10];
	private int longest = 10;
	private int size = 0;
	
	public void Push(int a) {//入栈
		if(size<longest) {
			array[size] = a;
			size++;
		}
		else {//如果栈满就将栈容量扩大为原来的2倍
			int[] temp = array;
			longest *= 2;
			array = new int[longest];
			System.arraycopy(temp, 0, array, 0, temp.length);
			array[size] = a;
			size++;
		}
	}
	public int Pop() {//出栈
		if(size>0&&size>=longest/3&&size>100) {//如果栈容量大于100且使用的栈空间小于1/3
			int[] temp = array;					//则将栈容量缩小为原来的1/2
			longest /= 2;
			array = new int[longest];
			System.arraycopy(temp, 0, array, 0, temp.length);
			size--;
			return array[size];
		}
		else if(size == 0){
			System.out.println("栈为空");
			return 0;
		}
		else {
			size--;
			return array[size];
		}
	}
	public int GetSize() {//获取栈规模
		return size;
	}
	public boolean empty() {//判断栈是否为空
		return size == 0;
	}
}

2.使用链表实现栈（链栈）：

        与顺序栈比起来，使用链表来存储数据使得内存开销大大减小，需要多少内存就分配多少内存，不使用就将内存返还给系统，有很多优点。下面是链栈的实现：

        首先创建结点类：

public class Node <elemType>{
	elemType data;//存储数据
	@SuppressWarnings("rawtypes")
	Node next;//指向下一个结点
	//构造方法
	Node(){}
	Node(elemType data){
		this.data = data;
	}
	Node(elemType data, Node<elemType> e){
		this.data = data;
		this.next = e;
	}
}

        链栈实现：

public class Stack<elemType> {
	private int size = 0;
	Node<elemType> top = new Node<>(null);//栈顶
	
	//构造方法
	Stack(){}
	Stack(Node<elemType> e){
		top.data = e.data;
		top.next = e.next;
	}
	Stack(elemType data){
		top.data = data;
		top.next = null;
	}
	Stack(elemType data,Node<elemType> next){
		top.data = data;
		top.next = next;
	}
	
	public void Push(elemType data) {//入栈
		Node<elemType> oldTop = top;
		top = new Node<elemType>();
		top.data = data;
		top.next = oldTop;
		oldTop = null;
		size++;
	}
	@SuppressWarnings("unchecked")
	public elemType Pop() {//出栈
		if(size != 0) {
			elemType data;
			data = top.data;
			top = top.next;
			size--;
			return data;
		}
		else {
			return null;
		}
	}
	public int getSize() {//获取栈规模
		return size;
	}
	public boolean empty() {//判断栈是否为空
		return size == 0;
	}
}