注意事项
基于数组的栈：
进栈push：相当于数组方法中的addLast();
出栈pop：相当于数组方法中的deleteLast();
查看栈顶peek：相当于数组方法中的getLast();
基于链表的栈：
进栈push：相当于链表方法中的addFirst();
出栈pop：相当于链表方法中的deleteFirst();
查看栈顶peek：相当于链表方法中的getFirst();
基于数组的栈ArrayStack
源代码
Array源代码
public class Array<E> {
private E[] data;
private int size;
// 构造函数，传入数组的容量capacity构造Array
public Array(int Capacity) {
data = (E[]) new Object[Capacity];
size = 0;
}
// 无参数的构造函数，默认数组的容量capacity=10
public Array(){
this(10);
}
// 获取数组的容量
public int getCapacity(){
return data.length;
}
// 获取数组中的元素个数
public int getSize(){
return size;
}
// 返回数组是否为空
public boolean isEmpty(){
return size==0;
}
// 在index索引的位置插入一个新元素e
public void insert(int index,E e){
if(index < 0 || index > size)
throw new IllegalArgumentException("insert is false");
if(size == data.length)
resize(2 * data.length);
for(int i = size - 1; i >= index ; i --)
data[i + 1] = data[i];
data[index]=e;
size++;
}
// 向所有元素后添加一个新元素
public void addLast(E e){
insert(size,e);
}
// 在所有元素前添加一个新元素
public void addFirst(E e){
insert(0,e);
}
// 获取index索引位置的元素
public E get(int index){
if(index < 0 || index >= size)
throw new IllegalArgumentException("Get failed. Index is illegal.");
return data[index];
}
// 修改index索引位置的元素为e
public void set(int index,E e){
if(index < 0 || index >= size)
throw new IllegalArgumentException("Set failed. Index is illegal.");
data[index]=e;
}
// 查找数组中是否有元素e
public boolean contains(E e){
for (int i = 0; i < size; i++) {
if(data[i].equals(e))
return true;
}
return false;
}
// 查找数组中元素e所在的索引，如果不存在元素e，则返回-1
public int find(E e){
for (int i = 0; i < size; i++) {
if(data[i].equals(e))
return i;
}
return -1;
}
// 从数组中删除index位置的元素, 返回删除的元素
public E delete(int index){
if(index < 0 || index >= size)
throw new IllegalArgumentException("Set failed. Index is illegal.");
E temp = data[index];
for(int i = index ; i < size - 1; i++){
data[i]=data[i+1];
}
data[size-1]=null;
size--;
if(size == data.length / 4 && data.length / 2 != 0)
resize(data.length / 2);
return temp;
}
// 从数组中删除第一个元素, 返回删除的元素
public E deleteFirst(){
return delete(0);
}
// 从数组中删除最后一个元素, 返回删除的元素
public E deleteLast(){
return delete(size-1);
}
// 从数组中删除元素e
public void deleteElement(E e){
int index=find(e);
if(index!=-1)
delete(index);
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append(String.format("Array : size = %d , capacity = %d\n", size, data.length));
res.append("[");
for (int i = 0; i < size; i++) {
res.append(data[i]);
if(i != size - 1)
res.append(", ");
}
res.append("]");
return res.toString();
}
// 将数组空间的容量变成newCapacity大小
private void resize(int newCapacity){
E[] newData = (E[])new Object[newCapacity];
for(int i = 0 ; i < size ; i ++)
newData[i] = data[i];
data = newData;
}
}
ArrayStack源代码
public class ArrayStack<E> implements Stack<E>{
private Array<E> array;
public ArrayStack(int Capacity){
array=new Array<>(Capacity);
}
public ArrayStack(){
this(10);
}
@Override
public int getSize() {
return array.getSize();
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
@Override
public void push(E e) {
array.addLast(e);
}
@Override
public E pop() {
return array.deleteLast();
}
@Override
public E peek() {
return array.get(array.getSize()-1);
}
@Override
public String toString(){
StringBuilder res =new StringBuilder();
res.append("Stack : [");
for(int i=0;i<array.getSize();i++){
res.append(array.get(i));
if(i!=array.getSize()-1)
res.append(" , ");
}
res.append("] top ");
return res.toString();
}
}
测试用例主函数
public class Main {
public static void main(String[] args) {
ArrayStack<Integer> stack = new ArrayStack<>();
for(int i = 0 ; i < 5 ; i ++){
stack.push(i);
System.out.println(stack);
}
stack.pop();
System.out.println(stack);
System.out.println(stack.peek());
}
}
结果
Stack : [0] top
Stack : [0 , 1] top
Stack : [0 , 1 , 2] top
Stack : [0 , 1 , 2 , 3] top
Stack : [0 , 1 , 2 , 3 , 4] top
Stack : [0 , 1 , 2 , 3] top
3
进程已结束,退出代码0
基于链表的栈LinkedListStack
源代码
LinkedList源代码
public class LinkedList<E> {
private class Node{
public E e;
public Node next;
public Node(E e, Node next){
this.e = e;
this.next = next;
}
public Node(E e){
this(e, null);
}
public Node(){
this(null, null);
}
@Override
public String toString(){
return e.toString();
}
}
private Node dummyHead;
private int size;
public LinkedList(){
dummyHead = new Node();
}
// 获取链表中的元素个数
public int getSize(){
return size;
}
// 返回链表是否为空
public boolean isEmpty(){
return size == 0;
}
// 在链表的index(0-based)位置添加新的元素e
// 在链表中不是一个常用的操作，练习用：）
public void add(int index, E e){
if(index < 0 || index > size)
throw new IllegalArgumentException("index is error");
Node prev = dummyHead;
for(int i = 0 ; i < index ; i ++)
prev=prev.next;
prev.next=new Node(e,prev.next);
size++;
}
// 在链表头添加新的元素e
public void addFirst(E e){
add(0,e);
}
// 在链表末尾添加新的元素e
public void addLast(E e){
add(size,e);
}
// 获得链表的第index(0-based)个位置的元素
// 在链表中不是一个常用的操作，练习用：）
public E get(int index){
if(index < 0 || index >= size)
throw new IllegalArgumentException("Get failed. Illegal index.");
Node cur = dummyHead.next;
for(int i =0 ; i < index ; i ++)
cur=cur.next;
return cur.e;
}
// 获得链表的第一个元素
public E getFirst(){
return get(0);
}
// 获得链表的最后一个元素
public E getLast(){
return get(size-1);
}
// 修改链表的第index(0-based)个位置的元素为e
// 在链表中不是一个常用的操作，练习用：）
public void set(int index, E e){
if(index < 0 || index >= size)
throw new IllegalArgumentException("set failed. Illegal index.");
Node cur = dummyHead.next;
for(int i = 0 ; i < index ; i ++)
cur= cur.next;
cur.e=e;
}
// 查找链表中是否有元素e
public boolean contains(E e){
Node cur = dummyHead.next;
while(cur.next!=null){
if(cur.e.equals(e))
return true;
cur=cur.next;
}
return false;
}
// 从链表中删除index(0-based)位置的元素, 返回删除的元素
// 在链表中不是一个常用的操作，练习用：）
public E remove(int index){
if(index < 0 || index >= size)
throw new IllegalArgumentException("Remove failed. Illegal index.");
Node prev =dummyHead;
for(int i = 0 ; i < index ; i ++)
prev=prev.next;
Node temp = prev.next;
prev.next=prev.next.next;
temp.next=null;
size--;
return temp.e;
}
// 从链表中删除第一个元素, 返回删除的元素
public E removeFirst(){
return remove(0);
}
// 从链表中删除最后一个元素, 返回删除的元素
public E removeLast(){
return remove(size-1);
}
// 从链表中删除元素e
public void removeElement(E e){
Node prev = dummyHead;
while(prev.next!=null){
if(prev.next.e.equals(e))
break;
prev=prev.next;}
if(prev.next!=null){
Node temp = prev.next;
prev.next = prev.next.next;
temp.next =null;
size--;
}
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append("LinkedList : ");
Node cur = dummyHead.next;
while(cur !=null){
res.append(cur.e + "->");
cur=cur.next;
}
res.append("null");
return res.toString();
}
}
LinkedListStack
public class LinkedListStack<E> implements Stack<E>{
private LinkedList<E> list;
public LinkedListStack(){
list =new LinkedList<>();
}
@Override
public int getSize() {
return list.getSize();
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public void push(E e) {
list.addFirst(e);
}
@Override
public E pop() {
return list.removeFirst();
}
@Override
public E peek() {
return list.getFirst();
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append("Stack: top ");
res.append(list);
return res.toString();
}
public static void main(String[] args) {
LinkedListStack<Integer> stack = new LinkedListStack<>();
for(int i = 0 ; i < 5 ; i ++){
stack.push(i);
System.out.println(stack);
}
stack.pop();
System.out.println(stack);
}
}
测试用例主函数
public class Main {
public static void main(String[] args) {
LinkedListStack<Integer> stack = new LinkedListStack<>();
for(int i = 0 ; i < 5 ; i ++){
stack.push(i);
System.out.println(stack);
}
stack.pop();
System.out.println(stack);
System.out.println(stack.peek());
}
}
结果
Stack: top LinkedList : 0->null
Stack: top LinkedList : 1->0->null
Stack: top LinkedList : 2->1->0->null
Stack: top LinkedList : 3->2->1->0->null
Stack: top LinkedList : 4->3->2->1->0->null
Stack: top LinkedList : 3->2->1->0->null
3
//基于ArrayStack数组和LinkedListStack链表的栈所得到的结果相同
进程已结束,退出代码0
基于ArrayStack数组和LinkedListStack链表的运行速度比较
源代码
import java.util.Random;
public class Main {
// 测试使用stack运行opCount个push和pop操作所需要的时间，单位：秒
private static double testStack(Stack<Integer> stack , int opCount){
Long startTime = System.nanoTime();
Random rd = new Random();
for (int i = 0; i < opCount; i++) {
stack.push(rd.nextInt(Integer.MAX_VALUE));
}
for (int i = 0; i < opCount; i++) {
stack.pop();
}
Long endTime = System.nanoTime();//此方法得到的时间是纳秒级别
return (endTime-startTime)/1000000000.0;
}
public static void main(String[] args) {
int num = 10000000;
ArrayStack<Integer> one = new ArrayStack<>();
System.out.println("ArrayStack 消耗的时间为 ："+Main.testStack(one,num) +"s");
LinkedListStack<Integer> two = new LinkedListStack<>();
System.out.println("LinkedListStack 消耗的时间为 ：" + Main.testStack(two,num) + "s");
}
}
结果
ArrayStack 消耗的时间为 ：1.555003s
LinkedListStack 消耗的时间为 ：1.0377532s
进程已结束,退出代码0