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)
设计你的循环队列实现。 循环队列是一种线性数据结构,其操作表现基于 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;
}
}