数据结构—栈、队列、链表

一、栈 Stack（存取O(1)）

先进后出，进去123，出来321。
基于数组：最后一位为栈尾，用于取操作。
基于链表：第一位为栈尾，用于取操作。

1.1、数组栈 

/**
 * 基于数组实现的顺序栈； items[0]：表头/栈底；  items[size-1]：表尾/栈顶；
 */
public class MyArrayStack {
    // 存储元素的 数组
    private String items[];
    // 栈实际大小
    private int size =0;
    // 栈的容量
    private int capacity = 0;

    public MyArrayStack(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        this.items = new String[capacity];
    }

    /**
     * 入栈
     */
    public boolean push(String item) {
        if(size >= capacity){
            throw new IndexOutOfBoundsException("MyArrayStack 栈的内存满了");
        }
        items[size] = item;
        size++;
        return true;
    }

    /**
     * 出栈
     */
    public String pop() {
        if(size<=0){
            throw new IndexOutOfBoundsException("MyArrayStack 栈的内存空了");
        }
        String item = items[size-1];
        items[size-1] = null;
        size--;
        return item;
    }
}

1.2、链表栈 

/**
 * 基于链表实现的链式栈  top: 表尾/栈顶；
 */
public class MyLinkedStack {

    // 表尾/栈顶；
    private Node top = null;

    /**
     * 入栈
     */
    public void push(String value) {
        Node node = new Node(value,null);
        if(top != null){
            node.nextNode = top;
        }
        top = node;
    }

    /**
     * 出栈
     */
    public String pop() {
        if(top==null){
            throw new IndexOutOfBoundsException("MyLinkedStack 栈的内存空了");
        }
        String retValue = top.getValue();
        top = top.nextNode;
        return retValue;
    }

    /**
     * 节点
     */
    private static class Node{
        // 存储数据
        private String value;
        // 下个节点
        private Node nextNode;
        public Node(String value, Node nextNode) {
            this.value = value;
            this.nextNode = nextNode;
        }
        public String getValue() {
            return value;
        }
    }
}

二、队列 Queue （存取O(1)）

先进先出（FIFO）的有序列表 

2.1、数组单向队列 （存取O(1)）

/**
 * 基于数组实现的顺序队列
 */
public class MyArrayQueue {

    private String [] items;

    // 容量
    private int capacity = 0;

    // 队头下标
    private int head = 0;

    // 队尾下标
    private int tail = 0;

    public MyArrayQueue(int capacity) {
        this.items = new String [capacity];
        this.capacity = capacity;
    }

    /**
     * 入队
     */
    public boolean enqueue(String item) {
        if(capacity == tail){
            throw new IndexOutOfBoundsException("MyArrayQueue 容量满了");
        }
        items[tail] = item;
        tail++;
        return true;
    }

    /**
     * 出队
     */
    public String dequeue() {
        if(head==tail){
            throw new IndexOutOfBoundsException("MyArrayQueue 容量空了");
        }
        String retValue = items[head];
        head++;
        return retValue;
    }
}

2.2、链表单向队列 

/**
 * 基于链表实现的链式队列
 */
public class MyLinkedListQueue {
    // 队头
    private Node head = null;
    // 队尾
    private Node tail = null;

    /**
     * 入队
     */
    public void enqueue(String value) {
        Node node = new Node(value,null);
        if(tail==null){
            head = node;
            tail = node;
        }else {
            tail.next=node;
            tail=node;
        }
    }

    /**
     * 出队
     */
    public String dequeue() {
        if(head==null){
            throw new IndexOutOfBoundsException("MyLinkedListQueue 队列空了");
        }
        String retValue = head.getValue();
        head = head.next;
        if (head == null) {
            tail = null;
        }
        return retValue;
    }

    private static class Node{
        private String value;
        private Node next;
        public Node(String value, Node next) {
            this.value = value;
            this.next = next;
        }
        public String getValue() {
            return value;
        }
    }
}

三、链表 LinkedList 

3.1、单向链表 

/**
 * 单向普通链表
 */
public class MyLinkedList {
    // 链表大小
    private int size;
    // 表头
    private Node head;

    /**
     * 插入
     */
    public void insert(int index, String value) {
        if(index<0){
            throw new IndexOutOfBoundsException("MyLinkedList 下标越界了");
        } else {
            if(head==null){
                head = new Node(value,null);
            }else {
                if(index>=size){
                    index = size-1;
                }
                Node prev = head;
                for(int i=0;i=size) {
            throw new IllegalArgumentException("MyLinkedList 下标越界了");
        }
        Node prev = head;
        for (int i=0;i

3.2、双向链表 

public class MyDoubleLinkedList {
    // 链表大小
    private int size;
    // 表头
    private Node head;
    // 表尾
    private Node tail;

    /**
     * 插入
     */
    public void insert(int index,String data) {
        if(index < 0) {
            throw new IndexOutOfBoundsException("MyDoubleLinkedList  insert 下标越界");
        }
        Node node = new Node(data,null,null);
        if(index == 0) {
            head.next = node.next;
            head= node;
            return;
        }
        if(index >= size) {
            tail.prev = node.prev;
            tail= node;
            return;
        }
        Node cur = this.head;
        while(index != 0) {
            cur = cur.next;
            index--;
        }
        node.next = cur;
        cur.prev.next = node;
        node.prev = cur.prev;
        cur.prev = node;
    }

    public String get(int index){
        if(index<0||index>size){
            throw new IndexOutOfBoundsException("MyDoubleLinkedList get 下标越界了");
        }
        if(index<=(size/2)){
            Node cur = head;
            for(int i = 0;iindex;i--){
                cur = cur.prev;
            }
            return cur.getValue();
        }
    }


    private class Node{
        public String value;
        public Node prev;
        public Node next;
        public Node(String value, Node prev, Node next) {
            this.value = value;
            this.prev = prev;
            this.next = next;
        }

        public String getValue() {
            return value;
        }
    }
}

3.3、跳表