2.2堆栈（java实现）

堆栈的抽象数据类型描述

堆栈：具有一定操作约束的线性表
只在一端（栈顶，Top）做插入、删除
插入数据：入栈
删除数据：出栈
后入先出

堆栈的顺序存储实现

代码实现

package unit2.section2.demo1;

import java.io.IOException;

//栈的顺序存储
public class MyStack {
    
    
	private Object data[];
	private int top;
	private static final int maxSize=10;
	public MyStack() {
    
    
		this.data=new Object[maxSize];
		this.top=-1;
	}
	public MyStack(int size) {
    
    
		this.data=new Object[size];
		this.top=-1;
	}
	
	//入栈操作
	public void push(MyStack p,Object value) {
    
    
		if(p.top==data.length-1) {
    
    
			System.out.println("堆栈满");
		}else {
    
    
			p.data[++p.top]=value;
		}
	}
	
	//出栈操作
	public Object pop(MyStack p) throws Exception{
    
    
		Object value=0;
		if(p.top==-1) {
    
    
			throw new IOException("堆栈空");
		}else {
    
    
			value=p.data[p.top--];
		}
		return value;
	}
	
	public static void main(String[] args) throws Exception {
    
    
		MyStack ms=new MyStack();
		ms.push(ms, 10);
		Object ob=ms.pop(ms);
		System.out.println(ob);
	}
}

例题

代码实现

package unit2.section2.demo1;

import java.io.IOException;

public class MyStack2 {
    
    
	private Object data[];
	private int top1;
	private int top2;
	private static final int maxSize=10;
	public MyStack2() {
    
    
		data=new Object[maxSize];
		this.top1=-1;
		this.top2=maxSize;
	}
	public MyStack2(int size) {
    
    
		data=new Object[size];
		this.top1=-1;
		this.top2=size;
	}
	
	//入栈
	public void push(MyStack2 p,Object value,int tag) throws Exception{
    
    
		if(p.top2-p.top1==1) {
    
    
			throw new IOException("堆栈已满");
		}
		if(tag==1) {
    
    
			p.data[++p.top1]=value;
		}else {
    
    
			p.data[--p.top2]=value;
		}
	}
	
	//出栈
	public Object pop(MyStack2 p,int tag) throws Exception{
    
    
		Object value=0;
		if(p.top1==-1&&p.top2==data.length) {
    
    
			throw new IOException("栈空");
		}
		if(tag==1) {
    
    
			value=p.data[p.top1--];
		}else {
    
    
			value=p.data[p.top2++];
		}
		return value;
	}
	
	
}

堆栈的链式存储实现

代码实现

package unit2.section2.demo1;

public class Node {
    
    
	private Object data;
	private Node next;
	
	public Node() {
    
    
		this.next=null;
	}

	public Object getData() {
    
    
		return data;
	}

	public void setData(Object data) {
    
    
		this.data = data;
	}

	public Node getNext() {
    
    
		return next;
	}

	public void setNext(Node next) {
    
    
		this.next = next;
	}
	
}

package unit2.section2.demo1;

import java.io.IOException;

//堆栈的链式存储
public class MyStack3 {
    
    
	//判断堆栈是否为空
	public int isEmpty(Node node) {
    
    
		if(node.getNext()==null) {
    
    
			return 1;
		}
		else {
    
    
			return 0;
		}
	}
	
	//插入栈顶元素	注意：头结点还是没有元素，我们是插入到头结点的后面
	//因为我们链表的头才是top嘛
	public void push(Node p,Object vlaue) {
    
    
		Node newNode=new Node();
		newNode.setData(vlaue);
		newNode.setNext(p.getNext());
		p.setNext(newNode);
	}
	
	//删除栈顶元素并返回值
	public Object pop(Node p) throws Exception{
    
    
		if(p.getNext()==null) {
    
    
			throw new IOException("堆栈空");
		}
		Node oldNode=new Node();
		oldNode=p.getNext();
		p.setNext(oldNode.getNext());
		Object value=oldNode.getData();
		return value;
	}
}