008 | 数据结构—队列

写在前面：按引擎的检索原理来看，这样的标题被看到的概率就很低了！

1. 队列：只允许在一端进去插入操作，在另一端进行删除操作的线性表，允许插入的一端成为列尾，允许删除的一端成为列头
2. 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());
    }


}

测试结果：