队列、栈、循环队列的java实现

1、队列的java内部实现

java中有Queue的接口，实现类为LinkedList

import java.util.Queue;
import java.util.LinkedList;
public class Queue {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        
        //增加元素
        queue.offer("zhangsan");
        queue.offer("lisi");
        queue.offer("wangwu");
        
        //拿出队列头元素
        String str1 = queue.poll();
        System.out.println(str1);    //zhangsan

        //返回队列头的元素但是不弹出
		String str2 = queue.peek();
        System.out.println(str2);    //lisi

        //返回当前队列有几个数
        System.out.println(queue.size());    //2
    }
}

2、队列的数组实现

public class Quene {
    int[] queue;
    int left, right;

    public Quene(int k) {
        queue = new int[k];
    }
    
    public void offer(int num) {
        queue[right++] = num;
    }
    
    public int poll() {
        return queue[left++];
    }
    public boolean isempty() {
        return left == right;
    }
    public int head() {
        return queue[left];
    }
    public int tail() {
        return queue[right-1];
    }
    public int size() {
        return right - 1;
    }
}

3、栈的java内部实现

import java.util.Stack;
public class Stack {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        
        //增加元素
        stack.push("zhangsan");
        stack.push("lisi");
        stack.push("wangwu");
        
        //弹出栈内元素
        String str1 = stack.pop();
        System.out.println(str1);    //wangwu

        //返回栈内元素但是不弹出
		String str2 = stack.peek();
        System.out.println(str2);    //lisi

        //返回当前队列有几个数
        System.out.println(stack.size());    //2
    }
}

4、栈的数组实现

import java.util.Stack;
public class Stack2 {

		public int[] stack;
		public int size;

		// 同时在栈里的元素个数不会超过n
		public Stack2(int n) {
			stack = new int[n];
			size = 0;
		}

		// 调用任何方法之前，先调用这个方法来判断栈内是否有东西
		public boolean isEmpty() {
			return size == 0;
		}

		public void push(int num) {
			stack[size++] = num;
		}

		public int pop() {
			return stack[--size];
		}

		public int peek() {
			return stack[size - 1];
		}

		public int size() {
			return size;
		}

	}

5、设计循环队列(leetcode:622)

622. 设计循环队列 - 力扣（LeetCode）

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

你的实现应该支持如下操作：

• MyCircularQueue(k): 构造器，设置队列长度为 k 。
• Front: 从队首获取元素。如果队列为空，返回 -1 。
• Rear: 获取队尾元素。如果队列为空，返回 -1 。
• enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
• deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
• isEmpty(): 检查循环队列是否为空。
• isFull(): 检查循环队列是否已满。

class MyCircularQueue {
    public int[] queue;    //用数组实现循环队列
    public int left, right, size, limit;    //left和right表示左索引和右索引，size表示现在队列中有几个元素，limit表示循环队列的最大容量
    public MyCircularQueue(int k) {
        this.queue = new int[k];
        limit = k;    //循环队列的最大容量为k
    }
    
    public boolean enQueue(int value) {
        if (isFull()) {
            return false;
        }
        queue[right] = value;
        right = right == limit - 1 ? 0 : right + 1;    //加入元素时，右索引的值为value，右索引往后移一位，如果右索引是最后一个位置，则移到0位置，保证循环利用
        size++;    
        return true;
    }
    
    public boolean deQueue() {
        if (isEmpty()) {
            return false;
        }
        left = left == limit - 1 ? 0 : left + 1;    //删除元素，left往后移一位，如果left已经是最后一个位置，则移到0位置
        size--;
        return true;
    }
    
    public int Front() {
        if (isEmpty()) {
            return -1;
        }
        return queue[left];
    }
    
    public int Rear() {
        if (isEmpty()) {
            return -1;
        }
        return queue[right == 0 ? limit - 1 : right - 1];
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public boolean isFull() {
        return size == limit;
    }
}