Java自定义栈

前言：以下为自主设计栈，供理解用
栈接口：

package DataStructure.stacks;

import java.util.List;

public interface IStack<E> {
	
	//1.判断空栈
	public boolean isEmpty();
	
	
	//2.判断栈满，链栈始终为false，除非虚拟机栈内存耗尽
	public boolean isMax();
	
	//3.入栈
	public boolean push(E e);

	//4.出栈
	public E pop();
	
	//5.返回栈顶
	public E peek();
	
	/**
	 * 6.返回栈元素在栈中的位置
	 * OrderStack:返回栈元素在栈中的位置，栈底元素位置为0，
	 * LinkedStack:返回栈元素在栈中的位置，栈底元素位置为0
	 * @param e
	 * @return
	 */
	public int getIndex(E e);
	
	//7.返回栈的实际长度
	public int size();
	
	//8.返回栈容量,链栈因为是动态扩容，实际长度等于栈大小
	public int getStackSize();
	
	//9.打印栈
	public List<E> display();
}

顺序栈：

	package DataStructure.stacks;

import java.util.ArrayList;
import java.util.List;

/**
 * 	顺序栈
 *
 * @class DataStructure.stacks.OrderStack
 * @author ljj
 * @date 2019-04-22
 * @notes
 * 
 * @param <E>
 */
public class OrderStack<E> implements IStack<E> {
	private	Object[] data = null; //数据栈
	private int top = -1;		  //栈顶指针初始化为-1
	private int maxSize = 0;	  //栈最大容量
	
	//默认设置栈容量为10
	public OrderStack() {
		this(10);
	}
	
	public OrderStack(int initialSize) {
		if (initialSize >= 0) {
			this.data = new Object[initialSize];//初始化数组
			this.maxSize = initialSize;			//设置栈最大容量
			this.top = -1;
		}
	}
	
	@Override
	public boolean isEmpty() {
		return top == -1 ? true : false;	//根据栈顶来判断栈是否为空
	}
	
	@Override
	public boolean isMax() {
		return top >= maxSize-1 ? true : false; //判断是否满栈
	}
	
	@Override
	public boolean push(E e) {
		if (isMax()) {
			System.err.println("栈已满");
			return false;
		}
		data[++top] = e;//将元素添加到列表中
		return true;
	}

	@Override
	@SuppressWarnings("unchecked")
	public E pop() {
		if (isEmpty()) {
			System.out.println("空栈");
			return null;
		}
		return (E)data[top--];
	}

	@Override
	@SuppressWarnings("unchecked")
	public E peek() {
		if (isEmpty()) {
			System.err.println("栈空");
			return null;
		}
		return (E)data[top];
	}

	//获取元素在栈中的位置
	@Override
	@SuppressWarnings("unchecked")
	public int getIndex(E e) {
		for(int index = top; index != -1; index--) {
			if (((E)data[index]).equals(e)) {
				return index;
			}
		}
		return -1;
	}
	
	//栈元素个数
	@Override
	public int size() {
		return this.top+1;	//栈顶值,为栈元素的实际个数
	}
	
	//栈大小
	@Override
	public int getStackSize() {
		return this.maxSize;
	}
	
	//打印栈元素
	@Override
	@SuppressWarnings("unchecked")
	public List<E> display() {
		List<E> list = new ArrayList<>();
		for(int index = top; index != -1; index--) {
			list.add((E)data[index]);
		}
		return list;
	}
}

链栈：

package DataStructure.stacks;

import java.util.ArrayList;
import java.util.List;

public class LinkedStack<E> implements IStack<E> {
	
	private Node top = null;	//定义栈顶
	private int	size = 0;		//定义栈节点数量
	
	//内部节点类
	private class Node {
		public Object data = null;	//数据域
		public Node next = null;	//指针域
		
		public Node(Object data, Node next) {
			this.data = data;
			this.next = next;
		}

		@Override
		public String toString() {
			return "Node [data=" + data + ", next=" + next + "]";
		}
	}
	
	@Override
	public boolean isEmpty() {
		return size == 0 ? true : false;
	}
	
	@Override
	public boolean isMax() {
		return false;
	}
	
	//压栈
	@Override
	public boolean push(E e) {
		top = new Node(e, top);
		size++;
		return true;
	}
	
	//出栈
	@Override
	@SuppressWarnings("unchecked")
	public E pop() {
		if (isEmpty()) {
			System.err.println("空栈");
			return null;
		}
		Node temp = top;
		top = top.next;
		temp.next = null;	//释放引用，删除指针指向(如果没有释放引用GC不会对对象进行回收)
		size--;
		return (E)temp.data;
	}

	@Override
	@SuppressWarnings("unchecked")
	public E peek() {
		return (E)this.top.data;
	}

	@Override
	@SuppressWarnings("unchecked")
	public int getIndex(E e) {
		Node tmp = top;
		for(int index = 0; tmp != null; index++) {
			if (((E)tmp.data).equals(e)) 
				return size-(index+1);		
			tmp = tmp.next;
		}
		return -1;
	}
	
	//返回栈大小
	@Override
	public int size() {
		return this.size;
	}

	@Override
	public int getStackSize() {
		return this.size;
	}

	@Override
	@SuppressWarnings("unchecked")
	public List<E> display() {
		List<E> list = new ArrayList<>();
		Node tmp = top;
		while(tmp != null) {
			list.add((E)tmp.data);
			tmp = tmp.next;
		}
		return list;
	}	
}

测试Demo：

void OrderStackDemo(){
		IStack<Integer> iStack = new OrderStack<>();
		for(int i = 0;i < 9;i++) {
			iStack.push(i);
		}
		System.out.println("index:"+iStack.getIndex(4)+"    栈大小："
				+iStack.getStackSize()+" 是否最大值："+iStack.isMax());
		System.out.println(iStack.display());
	}
	
	void LinkedStackDemo() {
		IStack<Integer> iStack = new LinkedStack<>();
		for(int i = 0;i < 9;i++) {
			iStack.push(i);
		}
		System.out.println("index:"+iStack.getIndex(4)+"    栈大小："
				+iStack.getStackSize()+" 是否最大值："+iStack.isMax());
		System.out.println(iStack.display());
	}

Console：

----------OrderStack------------
index:4    栈大小：10 是否最大值：true
栈已满
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
----------LinkedStack------------
index:4    栈大小：9 是否最大值：false
[8, 7, 6, 5, 4, 3, 2, 1, 0]

猜你喜欢