本关任务：实现队列基本操作，并使用队列基本操作解决密码加密和解密问题。 密码加密原理描述如下： 将明文（一个字符串）的每个字符按照字母表后移，每个字符的后移个数由秘钥值列表确定，如果明文比密钥值列表长，可以从头再使用这个密钥值列表。 如明文：student，秘钥：2345， 则加密方法是：s（向后移动2位）变成u，t（向后移动3位）变成w，u （向后移动4位）变成y，d（向后移动5位） 变成i，此时秘钥用完，所以从头开始用2进行移位加密，依此类推可以得到加密后的密文。而解密时，只需将密文根据秘钥反推就可

实现队列基本操作

我们可以使用数组来实现队列，具体实现如下：

public class MyQueue {
    private int[] data;
    private int front; // 队列头指针
    private int rear;  // 队列尾指针
    private int size;  // 队列大小

    public MyQueue(int capacity) {
        this.data = new int[capacity];
        this.front = 0;
        this.rear = -1;
        this.size = 0;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public boolean isFull() {
        return size == data.length;
    }

    public int size() {
        return size;
    }

    public void enqueue(int item) {
        if (isFull()) {
            throw new RuntimeException("Queue is full!");
        }
        rear = (rear + 1) % data.length;
        data[rear] = item;
        size++;
    }

    public int dequeue() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty!");
        }
        int item = data[front];
        front = (front + 1) % data.length;
        size--;
        return item;
    }

    public int peek() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty!");
        }
        return data[front];
    }
}

使用队列基本操作解决密码加密和解密问题

根据题目描述，我们可以将秘钥值列表作为一个循环队列，每次取出队列头的值进行加密，然后将该值重新加入队列尾，以便下次使用。具体实现如下：

public class PasswordUtils {
    public static String encrypt(String text, String key) {
        // 将明文文本转换成字符数组
        char[] chars = text.toCharArray();

        // 将秘钥值列表转换成整型数组
        int[] keys = new int[key.length()];
        for (int i = 0; i < key.length(); i++) {
            keys[i] = Integer.parseInt(String.valueOf(key.charAt(i)));
        }

        // 创建秘钥值列表的循环队列
        MyQueue queue = new MyQueue(keys.length);
        for (int i = 0; i < keys.length; i++) {
            queue.enqueue(keys[i]);
        }

        // 加密每一个字符
        StringBuilder sb = new StringBuilder();
        for (char c : chars) {
            int k = queue.dequeue(); // 取出队列头的值进行加密
            sb.append((char) ((c - 'a' + k) % 26 + 'a')); // 加密
            queue.enqueue(k); // 将该值重新加入队列尾
        }

        return sb.toString();
    }

    public static String decrypt(String cipher, String key) {
        // 将密文文本转换成字符数组
        char[] chars = cipher.toCharArray();

        // 将秘钥值列表转换成整型数组
        int[] keys = new int[key.length()];
        for (int i = 0; i < key.length(); i++) {
            keys[i] = Integer.parseInt(String.valueOf(key.charAt(i)));
        }

        // 创建秘钥值列表的循环队列
        MyQueue queue = new MyQueue(keys.length);
        for (int i = 0; i < keys.length; i++) {
            queue.enqueue(keys[i]);
        }

        // 解密每一个字符
        StringBuilder sb = new StringBuilder();
        for (char c : chars) {
            int k = queue.dequeue(); // 取出队列头的值进行解密
            sb.append((char) ((c - 'a' - k + 26) % 26 + 'a')); // 解密
            queue.enqueue(k); // 将该值重新加入队列尾
        }

        return sb.toString();
    }
}

这样，我们就实现了队列基本操作，并使用队列基本操作解决了密码加密和解密问题。