JAVA使用 oceanbase JAVA使用数组实现栈和队列

转载

JAVA小侠影 2023-11-14 06:56:00

文章标签 JAVA使用 oceanbase 链表 java 数据结构双向链表 文章分类 Java 后端开发

一、双向链表实现栈和队列

双向链表
比较方便，而且思路清晰的做法是，先使用双向链表实现双向队列。
双向队列可以在头部或者尾部添加或者弹出元素。
随后部分调用双向队列的功能，即可实现栈或队列的功能。（栈：只能从头部添加和弹出元素，链表：只能从头部添加元素，从尾部取出元素）。

// 双向链表
public static class Node<T> {
    public T value;
    public Node<T> last; // 前驱指针
    public Node<T> next; // 后继指针
    public Node(T data) {
        value = data;
    }
}

// 用双向链表实现双向队列
public static class DoubleEndsQueue<T>{
	// 双向链表需要设置头指针和尾指针指向头节点和尾节点
    public Node<T> head;
    public Node<T> tail;

    public void addFromHead(T value){
        Node<T> cur = new Node<T>(value);
        if (head == null){
            head = cur;
            tail = cur;
        } else {
            cur.next = head; // 新加节点的next指针指向head
            head.last = cur; // 原来的头节点的last指针指向新加节点
            head = cur; // 新加节点成为新的头节点
        }
    }

    public void addFromTail(T value){
        Node<T> cur = new Node<T>(value);
        if (head == null){
            head = cur;
            tail = cur;
        } else {
            cur.last = tail; // 新加节点的last指针指向tail
            tail.next = cur; // 原来的尾节点的next指针指向尾节点
            tail = cur; // 新加节点成为新的尾节点
        }
    }

    public T popFromHead(){
        if (head == null){
            return null;
        }
        Node<T> cur = head; // 获取头节点，用cur接收
        if(head == tail){
            head = null;
            tail = null;
        } else {
            head = head.next; // 现有头节点的后继节点成为新的头节点
            // 获取头节点，分割头节点与队列主体
            cur.next = null; // cur的next指针指向空内存
            head.last = null; // 新头节点的last指针指向空内存
        }
        return cur.value;
    }

    public T popFromTail() {
        if (tail == null) {
            return null;
        }
        Node<T> cur = tail; // 获取尾节点，用cur接收
        if (head == tail) {
            head = null;
            tail = null;
        } else {
            tail = tail.last; // 现有尾节点的前驱节点成为新的尾节点
            // 获取尾节点，分割尾节点与队列主体
            cur.last = null; // cur的last指针指向空内存
            tail.next = null; // 新尾节点的next指针指向空内存
        }
        return cur.value;
    }

    public boolean isEmpty() {
        return head == null;
    }
}

部分调用双向队列的功能，即为栈或队列
2.1 栈的实现
栈可以理解为只用双向队列的一端进行添加和弹出操作，只要在方法上稍做限制即可。

public static class MyStack<T> {
    private DoubleEndsQueue<T> queue;

    // 底层为上文实现的双向队列
    public MyStack(){
        queue = new DoubleEndsQueue<T>();
    }

    // 在栈的实现中只调用从头部添加的方法
    public void push(T value){
        queue.addFromHead(value);
    }

    // 和添加同理，只能从头部弹出
    public T pop(){
        return queue.popFromHead();
    }

    // 判空方法
    public boolean isEmpty(){
        return queue.isEmpty();
    }
}

2.2 队列的实现
单向队列的实现也就类似：限制只能从双向链表的一段添加，另一端弹出。

public static class MyQueue<T>{
    private DoubleEndsQueue<T> queue;

    public MyQueue(){
        queue = new DoubleEndsQueue<>();
    }

    // 限制只能从头部添加
    public void push(T value){
        queue.addFromHead(value);
    }

    // 限制只能从尾部弹出
    public T poll(){
        return queue.popFromTail();
    }

    // 判空方法
    public boolean isEmpty(){
        return queue.isEmpty();
    }
}

二、使用数组实现固定长度的栈

这种应用是比较容易理解和进行实现的：

public static class MyStack{
    private int[] arr;
    private int topIndex;
    private final int volume;

    public MyStack(int volume){
        arr = new int[volume];
        topIndex = 0;
        this.volume = volume;
    }

    public void push(int value){
        if(topIndex == volume){
            throw new RuntimeException("栈已满，无法继续添加");
        }
        topIndex++;
        arr[topIndex-1] = value;
    }

    public int pop(){
        if(topIndex == 0){
            throw new RuntimeException("栈已空，无法继续添加");
        }

        topIndex--;
        int value = arr[topIndex];
        arr[topIndex] = 0;
        return value;
    }
}

三、使用数组实现队列

这里需要用到环形的数组：
使得队列中用于取出元素的下标追赶用于添加元素的下标，当弹出/添加操作成功时，下标加一或回到零，用数组的元素最大数量限制两个下标之间的“差距”，若二者的“差距”等于数组长度，意味着队列已满，若二者的差距为0，意味着队列为空。

public class RingArrayToQueue {
    public static class MyQueue{
        private int[] arr;
        private int pushIndex;
        private int pollIndex;
        private int size;
        private final int limit;

        public MyQueue(int limit){
            arr = new int[limit];
            pushIndex = 0;
            pollIndex = 0;
            size = 0;
            this.limit = limit;
        }

        public void push(int value){
            if(size == limit){
                throw new RuntimeException("队列已满，无法继续添加");
            }
            size++;
            arr[pushIndex] = value;
            pushIndex = nextIndex(pushIndex);
        }

        public int poll(){
            if(size == 0){
                throw new RuntimeException("队列已空，无法继续取出");
            }
            size--;
            int value = arr[pollIndex];
            pollIndex = nextIndex(pollIndex);
            return value;

        }

        public int nextIndex(int currentIndex){
            return currentIndex < limit - 1? currentIndex+1:0;
        }
    }
}