栈
java预定义的栈实现
public class Stack<E> extends Vector<E>
实现方式为自定义实现的可变长数组,线程安全
- E push(E item) 把项压入堆栈顶部
- synchronized E pop() 移除堆栈顶部的对象,并作为此函数的值返回该对象
- synchronized E peek() 查看堆栈顶部的对象,但不从堆栈中移除它
- boolean empty() 测试堆栈是否为空
- synchronized int search(Object o) 返回对象在堆栈中的位置,以1为基数
import java.util.Stack;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test1 {
private final static Lock lock=new ReentrantLock();
public static void main(String[] args) {
Stack<Integer> stack=new Stack<>();
for(int i=1;i<=5;i++) {
stack.push(i);
}
Integer kk=stack.pop();
System.out.println(kk+"::"+stack.size());
int pos=stack.search(Integer.valueOf(4));
System.out.println("4位于栈中的索引号为"+pos);
Integer kk2=stack.peek();
System.out.println(kk2+"::"+stack.size());
while(!stack.empty()) {
System.out.println(stack.pop());
}
System.out.println(stack.size());
// lock.lock();
// try {
// pp();
// } finally {
// lock.unlock();
// }
}
public void pp() {
}
}
栈的实现
栈的实现可以有数组实现的顺序栈和链表结构的链式栈
数组实现的栈结构
如果需要一个支持动态扩容的顺序栈,则底层还需要以来一个支持动态扩容的数组,将原来的数据搬移到新数组中。也可以使用顺序栈支持动态扩容。
private Object[] items; //栈中存放的数据
private int size; //栈中存放数据的个数数据压栈--将数据存储在栈顶,如果栈已经满了则不允许再添加数据
数据弹栈--将数据栈栈顶的数据获取出来,同时删除栈顶数据,如果栈中没有数据则返回null
public class ArrayStack {
private Object[] items; //栈中存放的数据
private int size; //栈中存放数据的个数
public ArrayStack() {
this(10);
}
public ArrayStack(int capacity) {
items=new Object[capacity];
}
//数据压栈--将数据存储在栈顶
public boolean push(Object item) {
//如果栈已经满了则不允许再添加数据
if(size==items.length) {
return false;
}
items[size++]=item;
return true;
}
//数据弹栈--将数据栈栈顶的数据获取出来,同时删除栈顶数据
public Object pop() {
//如果栈中没有数据则返回null
if(size==0)
return null;
return items[--size];
}
}
如果需要一个支持动态扩容的顺序栈
public class ArrayStack2 {
private Object[] items;
private int size;
public ArrayStack2() {
this(10);
}
public ArrayStack2(int capacity) {
items=new Object[capacity];
}
public boolean push(Object item) {
if(size==items.length)
return false;
items[size++]=item;
return true;
}
public Object pop() {
if(size==0)
return null;
return items[--size];
}
}
总结
栈是一种用于存储数据的简单数据结构,栈与线性表的最大区别是数据的存取的操作,可以这样认为栈Stack是一种特殊的线性表,其插入和删除操作只允许在线性表的一端进行,一般而言,把允许操作的一端称为栈顶Top,不可操作的一端称为栈底Bottom,同时把插入元素的操作称为入栈Push,删除元素的操作称为出栈Pop。若栈中没有任何元素,则称为空栈
顺序栈,顾名思义就是采用顺序表实现的的栈,顺序栈的内部以顺序表为基础,实现对元素的存取操作,当然还可以采用内部数组实现顺序栈,这里使用内部数据组来实现栈,至于以顺序表作为基础的栈实现
import java.io.Serializable;
public class Test2 {
public static void main(String[] args) {
Stack<Integer> s=new SeqStack<>();
System.out.println("是否为空"+s.empty());
for(int i=0;i<5;i++) {
s.push(i);
}
System.out.println("栈顶数据为"+s.peek());
while(!s.empty())
System.out.println(s.pop());
}
}
//定义接口
interface Stack<T>{
//栈是否为空
boolean empty();
//data元素入栈
void push(T data);
//返回栈顶元素,未出栈
T peek();
//出栈,返回栈顶元素,同时从栈中移除该元素
T pop();
}
//如果不考虑编程成本,下一步应该定义抽象类,在抽象类中添加公共方法
class SeqStack<T> implements Stack<T>,Serializable{
//栈顶指针,-1代表空栈
private int top=-1;
//容量大小默认为10
private int capacity=10;
//存放元素的数组
private T[] array;
private int size;
public SeqStack() {
array=(T[])new Object[capacity];
}
// 一般情况下应该方法名称为getSize,但是遵循一般的使用习惯,所以命名为size()
public int size() {
return size;
}
@Override
public boolean empty() {
return this.top==-1;
}
//添加元素,从栈顶(数组尾部)插入
public void push(T data) {
// 判断容量是否充足
if(size==array.length)
ensureCapacity(size*2+1);
// 从栈顶添加元素
array[++top]=data;
size++;
}
private synchronized void ensureCapacity(int len) {
Object[] res=new Object[len];
System.arraycopy(array, 0, res, 0, this.size);
this.array=(T[])res;
}
// 获取栈顶元素的值,不删除
public T peek() {
if(empty())
throw new EmptyStackException();
return array[top];
}
// 从栈顶(顺序表尾部)删除
public T pop() {
if(empty())
throw new EmptyStackException();
size--;
return array[top--];
}
}
class EmptyStackException extends RuntimeException{
public EmptyStackException() {
super("空栈");
}
public EmptyStackException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
public EmptyStackException(String message, Throwable cause) {
super(message, cause);
}
public EmptyStackException(String message) {
super(message);
}
public EmptyStackException(Throwable cause) {
super(cause);
}
}