数据结构-Java实现栈

概念

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。栈是先进后出，出栈与入栈操作均在一端进行。

本文使用数组实现栈、使用容器实现栈、使用链表实现栈、两个队列实现栈

数组实现栈

代码实现

package com.billJiang.stack;import java.util.Arrays;import java.util.EmptyStackException;/** * Created by billJiang on 2016/11/29. * 用数组实现栈顶 */public class StackArray {    private Object[] array;    private int top;    private int size=3;    public StackArray(){        array=new Object[size];        top=-1;    }    public boolean isEmpty(){        return top==-1;    }    public Object  pop(){        if(top==-1){            throw new EmptyStackException();        }        return array[top--];    }    public Object peek(){        if(top==-1)            return null;        return array[top];    }    public Object push(Object element){        if(top==size-1){           array= Arrays.copyOf(array,size*2);        }        array[++top]=element;        return element;    }}

测试

package com.billJiang.stack;/** * Created by billJiang on 2016/11/29. */public class StackArrayTest {    public static void main(String[] args) {        StackArray stack=new StackArray();        stack.push(new Integer(1));        stack.push(new Integer(2));        stack.push(new Integer(3));        stack.push(new Integer(4));        stack.peek();        stack.pop();        stack.push(new Integer(5));    }}

容器实现栈

代码实现

package com.billJiang.stack;import java.util.ArrayList;import java.util.EmptyStackException;import java.util.List;/** * Created by billJiang on 2016/11/30. * 用ArrayList容器实现栈 */public class StackList<T> {    private List<T> list;    private int size;    public StackList(int size){        this.size=size;        list=new ArrayList<T>(size);    }    public T pop(){        if(this.isEmpty()){            throw new EmptyStackException();        }      return list.remove(list.size()-1);    }    public T peek(){        if(this.isEmpty()){            throw new EmptyStackException();        }        return list.get(list.size()-1);    }    public void push(T element){        list.add(element);    }    public boolean isEmpty(){       return list.isEmpty();    }    public int size(){        return list.size();    }    public boolean isFull(){        return list.size()==this.size;    }}

链表实现栈

链表节点定义

package com.billJiang.stack;/** * Created by billJiang on 2016/11/30. * 单向链表节点 */public class Node<T> {    private T item;    private Node<T> next;    public Node() {        this.item = null;        this.next = null;    }    public Node(T item, Node<T> next) {        this.item = item;        this.next = next;    }    public T getItem() {        return item;    }    public void setItem(T item) {        this.item = item;    }    public Node<T> getNext() {        return next;    }    public void setNext(Node<T> next) {        this.next = next;    }}

代码实现

package com.billJiang.stack;import java.util.EmptyStackException;/** * Created by billJiang on 2016/11/30. * 使用单项链表实现栈，出栈、入栈均在一头进行 */public class StackLinkedList<T> {    private Node<T> top;    public void push(T element) {        if (isEmpty()) {            top = new Node(element, null);        }        Node<T> node = new Node(element, top);        top = node;    }    public T pop() {        if (isEmpty())            throw new EmptyStackException();        T element = top.getItem();        top = top.getNext();        return element;    }    public T peek() {        if (isEmpty())            throw new EmptyStackException();        return top.getItem();    }    public boolean isEmpty() {        return top == null;    }}

两个队列实现栈

代码实现

思路：入栈在一个队列中进行，出栈时，将队列中其他元素移动另一个队列，剩下一个元素出队列，即出栈。

package com.billJiang.stack;import com.billJiang.queue.QueueArray;/** * Created by billJiang on 2016/12/1. * 两个队列实现栈 */public class StackQueue<T> {    private QueueArray<T> queue1;    private QueueArray<T> queue2;    private int maxLength;    public StackQueue(int initial) {        this.maxLength = initial;        queue1 = new QueueArray<>(initial);        queue2 = new QueueArray<>(initial);    }    public boolean push(T element) {        if (size() == maxLength) {            return false;        }        if (queue2.isEmpty())            queue1.put(element);        else            queue2.put(element);        return true;    }    public T pop() {        if(queue1.isEmpty()){            while(queue2.size()>1){                queue1.put(queue2.poll());            }            return queue2.poll();        }else{            while(queue1.size()>1){                queue2.put(queue1.poll());            }            return queue1.poll();        }    }    public T peek() {        T obj=null;        if(queue1.isEmpty()){            while(queue2.size()>0){                obj=queue2.poll();                queue1.put(obj);            }        }else{            while(queue1.size()>1){                obj=queue1.poll();                queue2.put(obj);            }        }        return obj;    }    public int size() {        return queue1.size() + queue2.size();    }}