数据结构——栈和队列

栈和队列是什么？

栈是先进后出的数据结构

队列是先进先出的数据结构

栈实现

数组栈

• push()将元素插入到数组末尾
• pop()返回并删除最后插入的元素（即栈顶）
• peek返回最后插入的元素（即栈顶）

class MyArrayStack<E> {
    private int size;
    private Object[] array;
    MyArrayStack() {
        array = new Object[10];
    }
    public E pop() {
        Object o = array[size - 1];
        size--;
        return (E) o;
    }
    public void push(E value) {
        array[size] = value;
        size++;
    }
    public E peek() {
        return (E) array[size - 1];
    }
    @NonNull
    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        for (int i = 0; i < size; i++) {
            if (i == size - 1) {
                stringBuilder.append(array[i]);
            } else {
                stringBuilder.append(array[i] + ", ");
            }
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }
}

测试代码

MyArrayStack<Integer> myStack = new MyArrayStack<>();
myStack.push(0);
myStack.push(1);
myStack.push(2);
System.out.println(myStack);
System.out.println(myStack.peek());
System.out.println(myStack.pop());
System.out.println(myStack);

单向链表栈（包括头指针）

• push()循环找到最后的节点进行链接（效率低）
• pop()循环找到并断开最后插入节点（即栈顶），返回其item
• peek()循环找到最后插入节点返回其item（即栈顶）

class MyLinkStack<E> {
    private Node<E> first;
    private int size;
    private static class Node<E> {
        E item;
        Node<E> next;
        Node(E element, Node<E> next) {
            this.item = element;
            this.next = next;
        }
    }
    public E pop() {
        Node<E> temp = first;
        for (int i = 0; i < size - 1; i++) {
            temp = first.next;
        }
        E item = temp.next.item;
        temp.next = null;
        size--;
        return item;
    }
    public void push(E value) {
        if (size == 0) {
            first = new Node<>(value, null);
        } else {
            Node<E> temp = first;
            for (int i = 0; i < size-1; i++) {
                temp = first.next;
            }
            temp.next = new Node<>(value, null);
        }
        size++;
    }
    public E peek() {
        Node<E> temp = first;
        for (int i = 0; i < size; i++) {
            temp = first.next;
        }
        return temp.item;
    }
    @NonNull
    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        Node<E> temp = first;
        stringBuilder.append("[");
        for (int i = 0; i < size; i++) {
            if (i == size - 1) {
                stringBuilder.append(temp.item);
            } else {
                stringBuilder.append(temp.item + ", ");
            }
            temp = temp.next;
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }
}

测试代码

MyLinkStack<Integer> myStack = new MyLinkStack<>();
myStack.push(0);
myStack.push(1);
myStack.push(2);
System.out.println(myStack);
System.out.println(myStack.peek());
System.out.println(myStack.pop());
System.out.println(myStack);

双向链表栈（包括头尾节点）

• push()连接到尾节点
• pop()断开尾节点，返回其item
• peek()返回尾节点item

class MyDoublyLinkStack<E> {
    private Node<E> first;
    private int size;
    private Node<E> last;
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> pre;
        Node(Node<E> pre, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.pre = pre;
        }
    }
    public E pop() {
        Node<E> temp = last.pre;
        E item = last.item;
        temp.next = null;
        last.pre = null;
        last = temp;
        size--;
        return item;
    }
    public void push(E value) {
        if (size == 0) {
            last = first = new Node<>(null, value, null);
        } else {
            Node<E> newNode = new Node<>(last, value, null);
            last.next = newNode;
            last = newNode;
        }
        size++;
    }
    public E peek() {
        return last.item;
    }
    @NonNull
    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        Node<E> temp = first;
        stringBuilder.append("[");
        for (int i = 0; i < size; i++) {
            if (i == size - 1) {
                stringBuilder.append(temp.item);
            } else {
                stringBuilder.append(temp.item + ", ");
            }
            temp = temp.next;
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }
}

测试代码

MyDoublyLinkStack<Integer> myStack = new MyDoublyLinkStack<>();
myStack.push(0);
myStack.push(1);
myStack.push(2);
System.out.println(myStack);
System.out.println(myStack.peek());
System.out.println(myStack.pop());
System.out.println(myStack); 

队列实现

数组队列

• add()在数组末尾添加元素
• remove()返回第一个元素，并将后续元素往前移动一个位置
• element()返回第一个元素

class MyQueue<E> {
    private int size;
    private Object[] array;
    MyQueue() {
        array = new Object[10];
    }

    public E remove() {
        Object o = array[0];
        System.arraycopy(array, 1, array, 0, size - 1);
        size--;
        return (E) o;
    }
    public void add(E value) {
        array[size] = value;
        size++;
    }
    public E element() {
        return (E) array[0];
    }
    @NonNull
    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        for (int i = 0; i < size; i++) {
            if (i == size - 1) {
                stringBuilder.append(array[i]);
            } else {
                stringBuilder.append(array[i] + ", ");
            }
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }
}

测试代码

MyQueue<Integer> myQueue= new MyQueue<>();
myQueue.add(0);
myQueue.add(1);
myQueue.add(2);
System.out.println(myQueue);
System.out.println(myQueue.element());
System.out.println(myQueue.remove());
System.out.println(myQueue);

单向链表队列（包括头指针）

• add()循环找到最后的节点进行链接
• remove()断开头节点并返回其item
• element()返回头节点item

class MyLinkQueue<E> {
    private Node<E> first;
    private int size;
    private static class Node<E> {
        E item;
        Node<E> next;
        Node(E element, Node<E> next) {
            this.item = element;
            this.next = next;
        }
    }
    public E remove() {
        Node<E> temp = first.next;
        E item = first.item;
        first = temp;
        size--;
        return item;
    }
    public void add(E value) {
        if (size == 0) {
            first = new Node<>(value, null);
        } else {
            Node<E> temp = first;
            for (int i = 0; i < size - 1; i++) {
                temp = first.next;
            }
            temp.next = new Node<>(value, null);
        }
        size++;
    }
    public E element() {
        return first.item;
    }
    @NonNull
    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        Node<E> temp = first;
        stringBuilder.append("[");
        for (int i = 0; i < size; i++) {
            if (i == size - 1) {
                stringBuilder.append(temp.item);
            } else {
                stringBuilder.append(temp.item + ", ");
            }
            temp = temp.next;
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }
}

测试代码

MyLinkQueue<Integer> myQueue= new MyLinkQueue<>();
myQueue.add(0);
myQueue.add(1);
myQueue.add(2);
System.out.println(myQueue);
System.out.println(myQueue.element());
System.out.println(myQueue.remove());
System.out.println(myQueue);

双向链表队列（包括头尾指针）

• add()链接到尾节点
• remove()断开头节点并返回其item
• element()返回头节点item

class MyDoublyLinkQueue<E> {
    private Node<E> first;
    private int size;
    private Node<E> last;
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> pre;
        Node(Node<E> pre, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.pre = pre;
        }
    }
    public E remove() {
        Node<E> temp = first.next;
        E item = first.item;
        temp.pre = null;
        first.next = null;
        first = temp;
        size--;
        return item;
    }
    public void add(E value) {
        if (size == 0) {
            last = first = new Node<>(null, value, null);
        } else {
            Node<E> newNode = new Node<>(last, value, null);
            last.next = newNode;
            last = newNode;
        }
        size++;
    }
    public E element() {
        return first.item;
    }
    @NonNull
    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        Node<E> temp = first;
        stringBuilder.append("[");
        for (int i = 0; i < size; i++) {
            if (i == size - 1) {
                stringBuilder.append(temp.item);
            } else {
                stringBuilder.append(temp.item + ", ");
            }
            temp = temp.next;
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }
}

测试代码

MyDoublyLinkQueue<Integer> myQueue = new MyDoublyLinkQueue<>();
myQueue.add(0);
myQueue.add(1);
myQueue.add(2);
System.out.println(myQueue);
System.out.println(myQueue.element());
System.out.println(myQueue.remove());
System.out.println(myQueue);

简单总结

对于栈和队列，其最佳实现方式是数组，其次是双向链表，最后是单向链表