Estructura de datos (VI) de la pila

montón

Pilas y colas son dos importantes estructuras de datos desde el punto de vista, pilas y colas estructura de datos se forma lineal, en el que las operaciones de base de sus pilas particularidad y colas a un subconjunto de la tabla de funcionamiento lineal, que son operaciones lineales están limitados tabla, se puede hacer referencia para definir una estructura de datos, pero desde la perspectiva del tipo de datos, que son dos importantes tipos de datos abstractos de mesa lineal difieren Debido a que se usan ampliamente entre los diversos sistemas de software, objeto-orientado de manera programación, son de tipo multi-datos.

La definición de tipos de datos abstracta pila

Pila : mesa lineal se define deleción o inserción final de la tabla sólo por lo tanto, la pila, el extremo trasero de la mesa tiene un significado especial, llamado. Superior de la pila , respectivamente, referido como el encabezado de extremo bajo la pila , no contiene elemento de lista vacía se conoce como una pila vacía.
pila Supongamos que S = (a1, a2, ... , an), dicho elemento de a1 es baja pila, un elemento de la pila. pila prensa elementos a1, a2, ..., an entrada de pedidos principio LIFO pila, el primer elemento de la pila debe elemento apareció. en otras palabras, la pila se modifica realizado (como se muestra en la Figura I). Por lo tanto, la pila también conocido , último en salir (LIFO) mesa lineal (estructura LIFO refirió a), que se caracteriza por la imagen disponible que muestra una estación de despacho del ferrocarril.
(Figura 1)
el funcionamiento básico de la inserción pila o supresión además de una parte superior exterior de la pila , así como la inicialización de la pila, y condenado vacía, tomar la parte superior de la pila de yuanes y así sucesivamente.

Pila lograr una variedad de maneras:
una: Array

package main.com.cs.stack;

import java.util.Arrays;
/**
 * 数组实现栈
 * @param <T>
 */
class Mystack1<T> {
    //实现栈的数组
    private Object[] stack;
    //数组大小
    private int size;
 
    Mystack1() {
        stack = new Object[10];//初始容量为10
    }
 
    //判断是否为空
    public boolean isEmpty() {
        return size == 0;
    }
 
    //返回栈顶元素
    public T peek() {
        T t = null;
        if (size > 0)
            t = (T) stack[size - 1];
        return t;
    }
    
    public void push(T t) {
        expandCapacity(size + 1);
        stack[size] = t;
        size++;
    }
 
    //出栈
    public T pop() {
        T t = peek();
        if (size > 0) {
            stack[size - 1] = null;
            size--;
        }
        return t;
    }
 
    //扩大容量
    public void expandCapacity(int size) {
        int len = stack.length;
        if (size > len) {
            size = size * 3 / 2 + 1;//每次扩大50%
            stack = Arrays.copyOf(stack, size);
        }
    }
}
 
public class ArrayStack {
    public static void main(String[] args) {
        Mystack1<String> stack = new Mystack1<>();
        System.out.println(stack.peek());
        System.out.println(stack.isEmpty());
        stack.push("java");
        stack.push("is");
        stack.push("beautiful");
        stack.push("language");
        System.out.println(stack.pop());
        System.out.println(stack.isEmpty());
        System.out.println(stack.peek());
    }
}

II: Lista

package main.com.cs.stack;

/**
 * 链表实现栈
 *
 * @param <T>
 */
class Mystack2<T> {
    //定义链表
    class Node<T> {
        private T t;
        private Node next;
    }
 
    private Node<T> head;
 
    //构造函数初始化头指针
    Mystack2() {
        head = null;
    }
 
    //入栈
    public void push(T t) {
        if (t == null) {
            throw new NullPointerException("参数不能为空");
        }
        if (head == null) {
            head = new Node<T>();
            head.t = t;
            head.next = null;
        } else {
            Node<T> temp = head;
            head = new Node<>();
            head.t = t;
            head.next = temp;
        }
    }
 
    //出栈
    public T pop() {
        T t = head.t;
        head = head.next;
        return t;
    }
 
    //栈顶元素
    public T peek() {
        T t = head.t;
        return t;
    }
 
    //栈空
    public boolean isEmpty() {
        if (head == null)
            return true;
        else
            return false;
    }
}
 
public class LinkStack {
    public static void main(String[] args) {
        Mystack2 stack = new Mystack2();
        System.out.println(stack.isEmpty());
        stack.push("Java");
        stack.push("is");
        stack.push("beautiful");
        System.out.println("栈顶:" + stack.peek());
        System.out.println("出栈:" + stack.pop());
        System.out.println("出栈:" +stack.pop());
        System.out.println("是否为null:" + stack.isEmpty());
        System.out.println("出栈:" + stack.pop() );
        System.out.println(stack.isEmpty());
    }
}

Tres: LinkList

package main.com.cs.stack;

import java.util.LinkedList;
 
/**
 * LinkedList实现栈
 *
 * @param <T>
 */
class ListStack<T> {
    private LinkedList<T> ll = new LinkedList<>();
 
    //入栈
    public void push(T t) {
        ll.addFirst(t);
    }
 
    //出栈
    public T pop() {
        return ll.removeFirst();
    }
 
    //栈顶元素
    public T peek() {
        T t = null;
        //直接取元素会报异常，需要先判断是否为空
        if (!ll.isEmpty())
            t = ll.getFirst();
        return t;
    }
 
    //栈空
    public boolean isEmpty() {
        return ll.isEmpty();
    }
}
 
public class LinkedListStack {
    public static void main(String[] args) {
        ListStack<String> stack = new ListStack();
        System.out.println(stack.isEmpty());
        System.out.println(stack.peek());
        stack.push("java");
        stack.push("is");
        stack.push("beautiful");
        System.out.println(stack.peek());
        System.out.println(stack.pop());
        System.out.println(stack.isEmpty());
        System.out.println(stack.peek());
    }
}