写在前面:按引擎的检索原理来看,这样的标题被看到的概率就很低了!
- 队列:只允许在一端进去插入操作,在另一端进行删除操作的线性表,允许插入的一端成为列尾,允许删除的一端成为列头
- java实现循环队列
package queue;
/**
* User: ZhangQi
* Date: 2019/3/14
* Time: 15:01
* Desc: 循序队列抽象数据类型
*/
public interface QueueTest {
/**
* 判断队列是否为空
* @return
*/
boolean isEmpty();
/**
* 队列最大长度
* @return
*/
int size();
/**
* 队列添加数据
* @param num
* @return
*/
boolean push(int num);
/**
* 队列删除数据
* @return
*/
int pop();
/**
* 判断队列是否已满
* @return
*/
boolean isFull();
/**
* 队列当前长度
* @return
*/
int length();
}
package queue;
/**
* User: ZhangQi
* Date: 2019/3/14
* Time: 15:09
* Desc: 循序队列实现类
*/
public class QueueTestImpl implements QueueTest {
private int[] data; //队列元素
private int front; //队列头指针
private int rear; //队列尾指针
/**
* 初始化队列
* @param n
*/
public QueueTestImpl(int n) {
this.data = new int[n];
this.front = 0;
this.rear = 0;
}
@Override
public boolean isEmpty() {
/** 当头尾指针重合的时候,表示链表为空 */
if (front == rear) return true;
return false;
}
@Override
public int size() {
return data.length;
}
@Override
public boolean push(int num) {
if (isFull()) return false;
data[rear] = num;
/** 如果尾指针在数组的末端则转到最前位置 */
rear = (rear + 1) % size();
return true;
}
@Override
public int pop() {
if (isEmpty()) return -1;
int num = data[front];
/** 如果头指针在数组的末端则转到最前位置 */
front = (front + 1) % size();
return num;
}
@Override
public boolean isFull() {
if ((rear + 1) % size() == front) return true;
return false;
}
@Override
public int length() {
return (rear - front + size()) % size();
}
}
package queue;
/**
* User: ZhangQi
* Date: 2019/3/14
* Time: 15:56
* Desc: 队列测试
*/
public class TestQueue {
public static void main(String[] args) {
QueueTestImpl queueTest = new QueueTestImpl(5);
System.out.println(queueTest.push(1));
System.out.println(queueTest.push(2));
System.out.println(queueTest.push(3));
System.out.println(queueTest.push(4));
System.out.println(queueTest.push(6));
System.out.println(queueTest.size());
System.out.println(queueTest.length());
while (!queueTest.isEmpty()) {
System.out.println(queueTest.pop());
}
}
}
测试结果:
3. java实现循环队列\
package queue;
/**
* User: ZhangQi
* Date: 2019/3/14
* Time: 19:08
* Desc: 两个队列实现一个栈
*/
public class Solution {
public QueueTest queue1 = new QueueTestImpl(10);
public QueueTest queue2 = new QueueTestImpl(10);
/**
* 将元素加入非空队列中,第一个元素两个都可以
* @param num
* @return
*/
public boolean push(int num) {
if(queue1.isEmpty()) return queue2.push(num);
return queue2.push(num);
}
/**
* 每次pop的时候,将非空队列中到元素push到另一个空到队列中,保留最后一个元素pop出来
* @return
*/
public int pop() {
if(queue2.isEmpty() && queue1.isEmpty()) return -1;
if (queue1.isEmpty()) {
while (queue2.length() != 1) {
queue1.push(queue2.pop());
}
return queue2.pop();
} else {
while (queue1.length() != 1) {
queue2.push(queue1.pop());
}
return queue1.pop();
}
}
public static void main(String[] args) {
Solution solution = new Solution();
System.out.println(solution.push(1));
System.out.println(solution.push(2));
System.out.println(solution.push(3));
System.out.println(solution.pop());
System.out.println(solution.pop());
System.out.println(solution.pop());
System.out.println(solution.pop());
}
}
测试结果: