数据结构实现（一）栈

转载：https://www.cnblogs.com/CherishFX/p/4608880.html

1、基于数组实现栈

package dataStructures;

public class StackArray<E> {

    private Object[] data = null;
    private int maxSize; //栈容量
    private int top = -1; //栈顶指针
    
    /**
     * 无参构造函数
     */
    StackArray(){
        this(10); //默认栈大小为10         
    }
    
    /**
     * 有参构造函数
     */
    StackArray(int initialSize){
        if(initialSize >= 0){
            this.maxSize = initialSize;
            data = new Object[initialSize];
            top = -1;
        }else{
            throw new RuntimeException("初始化大小不能小于0：" + initialSize);
        }
    }
    
    //进栈，第一个元素top=0；
    public boolean push(E e){
        if(top == maxSize - 1){
            throw new RuntimeException("栈已满，无法将元素入栈！");
        }else{
            data[++top] = e;
            return true;
        }
    }
    
    //弹出栈顶元素
    public E pop(){
        if(top == -1){
            throw new RuntimeException("栈为空！");
        }else{
            return (E)data[top--];
        }
    }
    
    //查看栈顶元素但不移除
    public E peek(){
        if(top == -1){
            throw new RuntimeException("栈为空！");
        }else{
            return (E)data[top];
        }
    }
    
    //判空
    public boolean empty(){
        return top == -1 ? true : false;
    }
    
    //返回对象在栈中的位置，以1为基数
    public int search(E e){
        int i = top;
        while(top != -1){
            if(peek() != e){
                top--;
            }else{
                break;
            }
        }
        int result = top + 1;
        top = i;
        return result;
    }
}

2、基于链表实现栈

package dataStructures;

// 链栈的节点
class Node<E> {
    E e; // 节点的值
    Node<E> next; // 该节点指向的下一个节点
    
    // 构造函数
    public Node(E e, Node next) {
        this.e = e;
        this.next = next;
    }
}

public class StackLink<E> {

    private Node<E> top = null; // 栈顶元素
    private int size = 0; // 当前栈大小

    // 当前栈大小
    public int length() {
        return size;
    }

    // 判空
    public boolean empty() {
        return size == 0;
    }

    /**
     * 入栈：让top句柄指向新创建的节点，新节点的next引用指向原来的栈顶元素top
     * Node的有参构造器就直接完成了新节点指向原栈顶节点的任务，然后top句柄指向新节点即可,这样就不用新建个句柄oldTop来暂存旧栈顶节点
     * 
     * @param e
     */
    public boolean push(E e) {
        top = new Node(e, top);
        size++;
        return true;
    }

    // 查看栈顶元素但不删除
    public Node<E> peek() {
        if (empty()) {
            throw new RuntimeException("空栈异常！");
        } else {
            return top;
        }
    }

    /**
     * 出栈：新建个temp句柄指向top节点，top句柄指向top的下一个节点，现在就是 temp -> top ->
     * 让temp.next=null释放即可
     */
    public Node<E> pop() {
        if (empty()) {
            throw new RuntimeException("空栈异常！");
        } else {
            Node<E> temp = top; // 得到栈顶元素
            top = top.next; // 让top引用指向原栈顶元素的下一个元素
            temp.next = null; // 释放原栈顶元素的next引用
            size--;
            return temp;
        }
    }
}

3、基于java.util.LinkedList实现

package dataStructures;

import java.util.LinkedList;

public class StackLinkedList<E> {
    private LinkedList<E> ll = new LinkedList<E>();

    // 入栈
    public void push(E e) {
        ll.addFirst(e);
    }

    // 查看栈顶元素但不移除
    public E peek() {
        return ll.getFirst();
    }

    // 出栈
    public E pop() {
        return ll.removeFirst();
    }

    // 判空
    public boolean empty() {
        return ll.isEmpty();
    }

    // 打印栈元素
    public String toString() {
        return ll.toString();
    }
}