数据结构----------堆栈

数据结构---------堆栈

　　　1. 堆栈图解

　　　　堆栈是一种相同数据类型的集合，所有的操作都在栈顶进行，具有后进先出（Last In First Out，LIFO）的特点，堆栈在计算机中的应用相当广泛，其基本示意图如下：

　　　2. 堆栈实现

　　本文通过两种方式实现堆栈数据结构：（1）基于动态数组的堆栈实现；（2）基于链表的堆栈实现

• 基于动态数组的堆栈实现

 

import java.util.Iterator;

/**
 * 基于可扩容数组的堆栈实现
 * @author Administrator
 *
 */
public class ResizingArrayStack<Item> implements Iterable<Item> {
    private static final int CAPACITY = 10;//默认初始化容量
    private Item[] items;//用数组存储数据
    private int top = -1;//栈顶指针
    public ResizingArrayStack (int capacity) {
        items = (Item[]) new Object[capacity];
    }
    public ResizingArrayStack() {
        this(CAPACITY);
    }
    
    /**
     * 调整数组的大小
     * @param max
     */
    private void resize(int max) {
        Item[] copy = (Item[]) new Object[max];
        for(int i = 0; i < max; i++) {
            copy[i] = items[i];
        }
        items = copy;
    }
    
    /**
     * 判断堆栈是否为空
     * @return
     */
    public boolean isEmpty() {
        return top == -1;
    }
    
    /**
     * 压栈
     * @param item
     */
    public void push(Item item) {
        //如果数组元素的下一个索引长度等于该数组的长度，对数组进行扩容
        if(++top == items.length) {
            resize(2 * items.length);
        }
        items[top] = item;
    }
    
    /**
     * 弹栈
     * @return
     */
    public Item pop() {
        Item item = null;
        if(isEmpty()) {
            throw new RuntimeException("堆栈数据为空");
        }
        item = items[top];
        items[top--] = null;//将当前top设为null，for GC
        //如果数组只被占满1/4，则缩减数组至原来1/2
        if(top > 0 && top == items.length/4) {
            resize(items.length/2);
        }
        return item;
    }
    
    /**
     * 返回栈顶元素
     * @return
     */
    public Item peek() {
        if(isEmpty()) {
            throw new RuntimeException("堆栈数据为空");
        }
        return items[top];
    }
    
    @Override
    public Iterator<Item> iterator() {
        // TODO Auto-generated method stub
        return new ReverseArrayIterator();
    }
    
    /**
     * 按出栈顺序遍历栈
     * @author Administrator
     *
     */
    private class ReverseArrayIterator implements Iterator<Item> {
        private int index = top;
        @Override
        public boolean hasNext() {
            return index >= 0;
        }

        @Override
        public Item next() {
            return items[index--];
        }
        
    }
}

 

 

 

• 基于链表的堆栈实现

 

import java.util.Iterator;

/**
 * 基于链表的堆栈实现
 * @author Administrator
 *
 * @param <Item>
 */
public class LinkedStack<Item> implements Iterable<Item>{
    private Node<Item> top;//栈顶元素
    private int size = 0;//堆栈的大小 
    private class Node<Item> {
        private Item item;
        private Node<Item> next;
        public Node(Item item) {
            this.item = item;
        }
    }
    
    /**
     * 
     * 压栈
     * @param item
     */
    public void push(Item item) {
        Node<Item> newNode = new Node<Item>(item);
        newNode.next = top;
        top = newNode;
        size++;
    }
    
    /**
     * 弹栈
     * @return
     */
    public Item pop() {
        Node<Item> returnNode = top;
        top = top.next;
        returnNode.next = null;//释放原栈顶next的引用
        size--;
        return returnNode.item;
    }
    
    /**
     * 返回栈顶元素
     * @return
     */
    public Item peek() {
        if(isEmpty()) {
            throw new RuntimeException("空栈");
        }
        return top.item;
    }
    
    /**
     * 返回栈的大小
     * @return
     */
    public int size() {
        return size;
    }
    
    /**
     * 判断栈是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }
    
    /**
     * 遍历栈
     */
    @Override
    public Iterator<Item> iterator() {
        return new Iterator<Item>() {
            private Node<Item> current = top;
            @Override
            public boolean hasNext() {
                return current != null;
            }

            @Override
            public Item next() {
                Item item = current.item;
                current = current.next;
                return item;
            }
            
        };
    }
}