求求各位大佬帮帮忙教教孩子咋写，按照springboot3.0一步一步做的，好人一生平安

西一木

完成以下算法题并提交运行“结果截图”和“代码文件”：

假设在周末舞会上，男士们和女士们进入舞厅时，各自排 成一队。跳舞开始时，依次从男队和女队的队头上各出一人 配成舞伴。规定每个舞曲能有一对跳舞者。若两队初始人数 不相同，则较长的那一队中未配对者等待下一轮舞曲。现要 求写一个程序，模拟上述舞伴配对问题。

第 1 行两个正整数，表示男士人数 m 和女士人数 n，1≤m，n≤1000；

第 2 行一个正整数，表示舞曲的数目 k，k≤1000。

输出共 k 行，每行两个数，之间用一个空格隔开，表示配对舞伴的序号，男士在前，女士在后。

分析：设计两个队列分别存放男士和女士。每对跳舞 的人一旦跳完后就回到队尾等待下次被选。

样例输入：

2 4

6

样例输出：

1 1

2 2

1 3

2 4

1 1

2 2


源码如下：
CircleQueueDemo.java:
class CircleQueue {
    private int maxSize;
    private int front;
    private int rear;
    private int[] arr;

    public CircleQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[maxSize];
        front = 0;
        rear = 0;
    }

    /**
     * 判断队列是否满
     * @return
     */
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }

    /**
     * 判断队列是否为空
     * @return
     */
    public boolean isEmpty() {
        return rear == front;
    }

    /**
     * 添加数据到队列
     * @param n
     */
    public void addQueue(int n) {
        if (isFull()) {
            System.out.println("Queue is full");
            return;
        }
        arr[rear] = n;
        rear = (rear + 1) % maxSize;
    }

    /**
     * 获取队列的数据，出队列
     * @return
     */
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }

    /**
     * 显示队列的所有数据
     */
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("Queue is empty");
            return;
        }
        for (int i = front; i < front + size(); i++) {
            System.out.print(arr[i % maxSize]+" ");
        }
    }

    /**
     * 求出当前队列有效数据的个数
     * @return
     */
    public int size() {
        return (rear + maxSize - front) % maxSize;
    }

    /**
     * 显示队列的头数据，注意不是取出数据
     * @return
     */
    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        return arr[front];
    }
}

public class CircleQueueDemo {
    public static void main(String[] args) {
        // 作业代码实现在这里
        
    }
}


CircleQueueLinkDemo.java:
class LinkNode {
    int data;
    LinkNode next;
    public LinkNode(int data) {
        this.data = data;
    }
}

class CircleQueueLink{
    LinkNode front;
    LinkNode rear;
    /**
     * 初始化队列
     */
    public CircleQueueLink(){
        front = rear = null;
    }
    /**
     * 添加数据到队列
     * @param data
     */
    public void addQueue(int data){
        // 创建新的节点
        LinkNode newNode = new LinkNode(data);
        // 如果队列为空，front和rear都指向新节点；否则，rear指向新节点，新节点指向front(形成循环队列)
        if(front == null){
            front = rear = newNode;
            rear.next = front;
        }else{
            rear.next = newNode;
            rear = newNode;
            rear.next = front;
        }
    }
    /**
     * 获取队列的数据，出队列
     */
    public int getQueue(){
        // 如果队列为空，抛出异常；
        if(front == null){
            throw new RuntimeException("Queue is empty");
        }
        int value = front.data;
        // 如果队列只有一个节点，front和rear都指向null；否则，front指向下一个节点，rear指向front
        if(front == rear){
            front = rear = null;
        }else{
            front = front.next;
            rear.next = front;
        }
        return value;
    }
    /**
     * 显示队列的所有数据
     */
    public void display(){
        LinkNode temp = front;
        if(front == null){
            System.out.println("Queue is empty");
        }else{
            while(temp.next != front){
                System.out.print(temp.data + " ");
                temp = temp.next;
            }
            System.out.print(temp.data);
            System.out.println();
        }
    }
    /**
     * 判断队列是否为空
     * @return
     */
    public boolean isEmpty(){
        return front == null;
    }
    /**
     * 求出当前队列有效数据的个数
     * @return
     */
    public int size(){
        int count = 0;
        LinkNode temp = front;
        if(front == null){
            return 0;
        }else{
            while(temp.next != front){
                count++;
                temp = temp.next;
            }
            count++;
        }
        return count;
    }
    /**
     * 获取队列的数据，不出队列
     * @return
     */
    public int getFront(){
        if(front == null){
            throw new RuntimeException("Queue is empty");
        }
        return front.data;
    }
}

public class CircleQueueLinkDemo{
    public static void main(String[] args) {
        // 作业代码实现在这里
    }
}

FishC

首先，我们需要理解题目的要求。

题目要求模拟舞伴配对问题，舞会开始时，男士和女士各自排成一队，每次从男队和女队的队头各出一个人配成舞伴。如果男队和女队初始人数不相同，则较长的队伍中未配对者等待下一轮舞曲。

我们可以使用队列来模拟这个过程。我们分别创建一个队列来存放男士和女士，每个队列中的元素表示一个人。

接下来，我们根据题目要求编写代码。

首先是使用数组实现的队列：

1. class CircleQueue {
   
2.     private int maxSize;
   
3.     private int front;
   
4.     private int rear;
   
5.     private int[] arr;
   
6. 
   
7.     public CircleQueue(int maxSize) {
   
8.         this.maxSize = maxSize;
   
9.         arr = new int[maxSize];
   
10.         front = 0;
    
11.         rear = 0;
    
12.     }
    
13. 
    
14.     /**
    
15.      * 判断队列是否满
    
16.      * @return
    
17.      */
    
18.     public boolean isFull() {
    
19.         return (rear + 1) % maxSize == front;
    
20.     }
    
21. 
    
22.     /**
    
23.      * 判断队列是否为空
    
24.      * @return
    
25.      */
    
26.     public boolean isEmpty() {
    
27.         return rear == front;
    
28.     }
    
29. 
    
30.     /**
    
31.      * 添加数据到队列
    
32.      * @param n
    
33.      */
    
34.     public void addQueue(int n) {
    
35.         if (isFull()) {
    
36.             System.out.println("Queue is full");
    
37.             return;
    
38.         }
    
39.         arr[rear] = n;
    
40.         rear = (rear + 1) % maxSize;
    
41.     }
    
42. 
    
43.     /**
    
44.      * 获取队列的数据，出队列
    
45.      * @return
    
46.      */
    
47.     public int getQueue() {
    
48.         if (isEmpty()) {
    
49.             throw new RuntimeException("Queue is empty");
    
50.         }
    
51.         int value = arr[front];
    
52.         front = (front + 1) % maxSize;
    
53.         return value;
    
54.     }
    
55. 
    
56.     /**
    
57.      * 显示队列的所有数据
    
58.      */
    
59.     public void showQueue() {
    
60.         if (isEmpty()) {
    
61.             System.out.println("Queue is empty");
    
62.             return;
    
63.         }
    
64.         for (int i = front; i < front + size(); i++) {
    
65.             System.out.print(arr[i % maxSize] + " ");
    
66.         }
    
67.     }
    
68. 
    
69.     /**
    
70.      * 求出当前队列有效数据的个数
    
71.      * @return
    
72.      */
    
73.     public int size() {
    
74.         return (rear + maxSize - front) % maxSize;
    
75.     }
    
76. 
    
77.     /**
    
78.      * 显示队列的头数据，注意不是取出数据
    
79.      * @return
    
80.      */
    
81.     public int headQueue() {
    
82.         if (isEmpty()) {
    
83.             throw new RuntimeException("Queue is empty");
    
84.         }
    
85.         return arr[front];
    
86.     }
    
87. }
    
88. 
    
89. public class CircleQueueDemo {
    
90.     public static void main(String[] args) {
    
91.         CircleQueue maleQueue = new CircleQueue(1000);
    
92.         CircleQueue femaleQueue = new CircleQueue(1000);
    
93. 
    
94.         // 输入男士和女士的人数
    
95.         int m = 2;
    
96.         int n = 4;
    
97. 
    
98.         // 将男士和女士依次加入队列
    
99.         for (int i = 1; i <= m; i++) {
    
100.             maleQueue.addQueue(i);
     
101.         }
     
102.         for (int i = 1; i <= n; i++) {
     
103.             femaleQueue.addQueue(i);
     
104.         }
     
105. 
     
106.         // 输入舞曲的数目
     
107.         int k = 6;
     
108. 
     
109.         // 配对舞伴
     
110.         for (int i = 0; i < k; i++) {
     
111.             int male = maleQueue.getQueue();
     
112.             int female = femaleQueue.getQueue();
     
113.             System.out.println(male + " " + female);
     
114.             maleQueue.addQueue(male);
     
115.             femaleQueue.addQueue(female);
     
116.         }
     
117.     }
     
118. }

复制代码

然后是使用链表实现的队列：

1. class LinkNode {
   
2.     int data;
   
3.     LinkNode next;
   
4.     public LinkNode(int data) {
   
5.         this.data = data;
   
6.     }
   
7. }
   
8. 
   
9. class CircleQueueLink{
   
10.     LinkNode front;
    
11.     LinkNode rear;
    
12.     /**
    
13.      * 初始化队列
    
14.      */
    
15.     public CircleQueueLink(){
    
16.         front = rear = null;
    
17.     }
    
18.     /**
    
19.      * 添加数据到队列
    
20.      * @param data
    
21.      */
    
22.     public void addQueue(int data){
    
23.         // 创建新的节点
    
24.         LinkNode newNode = new LinkNode(data);
    
25.         // 如果队列为空，front和rear都指向新节点；否则，rear指向新节点，新节点指向front(形成循环队列)
    
26.         if(front == null){
    
27.             front = rear = newNode;
    
28.             rear.next = front;
    
29.         }else{
    
30.             rear.next = newNode;
    
31.             rear = newNode;
    
32.             rear.next = front;
    
33.         }
    
34.     }
    
35.     /**
    
36.      * 获取队列的数据，出队列
    
37.      */
    
38.     public int getQueue(){
    
39.         // 如果队列为空，抛出异常；
    
40.         if(front == null){
    
41.             throw new RuntimeException("Queue is empty");
    
42.         }
    
43.         int value = front.data;
    
44.         // 如果队列只有一个节点，front和rear都指向null；否则，front指向下一个节点，rear指向front
    
45.         if(front == rear){
    
46.             front = rear = null;
    
47.         }else{
    
48.             front = front.next;
    
49.             rear.next = front;
    
50.         }
    
51.         return value;
    
52.     }
    
53.     /**
    
54.      * 显示队列的所有数据
    
55.      */
    
56.     public void display(){
    
57.         LinkNode temp = front;
    
58.         if(front == null){
    
59.             System.out.println("Queue is empty");
    
60.         }else{
    
61.             while(temp.next != front){
    
62.                 System.out.print(temp.data + " ");
    
63.                 temp = temp.next;
    
64.             }
    
65.             System.out.print(temp.data);
    
66.             System.out.println();
    
67.         }
    
68.     }
    
69.     /**
    
70.      * 判断队列是否为空
    
71.      * @return
    
72.      */
    
73.     public boolean isEmpty(){
    
74.         return front == null;
    
75.     }
    
76.     /**
    
77.      * 求出当前队列有效数据的个数
    
78.      * @return
    
79.      */
    
80.     public int size(){
    
81.         int count = 0;
    
82.         LinkNode temp = front;
    
83.         if(front == null){
    
84.             return 0;
    
85.         }else{
    
86.             while(temp.next != front){
    
87.                 count++;
    
88.                 temp = temp.next;
    
89.             }
    
90.             count++;
    
91.         }
    
92.         return count;
    
93.     }
    
94.     /**
    
95.      * 获取队列的数据，不出队列
    
96.      * @return
    
97.      */
    
98.     public int getFront(){
    
99.         if(front == null){
    
100.             throw new RuntimeException("Queue is empty");
     
101.         }
     
102.         return front.data;
     
103.     }
     
104. }
     
105. 
     
106. public class CircleQueueLinkDemo{
     
107.     public static void main(String[] args) {
     
108.         CircleQueueLink maleQueue = new CircleQueueLink();
     
109.         CircleQueueLink femaleQueue = new CircleQueueLink();
     
110. 
     
111.         // 输入男士和女士的人数
     
112.         int m = 2;
     
113.         int n = 4;
     
114. 
     
115.         // 将男士和女士依次加入队列
     
116.         for (int i = 1; i <= m; i++) {
     
117.             maleQueue.addQueue(i);
     
118.         }
     
119.         for (int i = 1; i <= n; i++) {
     
120.             femaleQueue.addQueue(i);
     
121.         }
     
122. 
     
123.         // 输入舞曲的数目
     
124.         int k = 6;
     
125. 
     
126.         // 配对舞伴
     
127.         for (int i = 0; i < k; i++) {
     
128.             int male = maleQueue.getQueue();
     
129.             int female = femaleQueue.getQueue();
     
130.             System.out.println(male + " " + female);
     
131.             maleQueue.addQueue(male);
     
132.             femaleQueue.addQueue(female);
     
133.         }
     
134.     }
     
135. }

复制代码

以上是使用数组和链表分别实现的队列，你可以根据自己的需求选择其中一种来实现。希望能帮到你，祝你和孩子学习愉快！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。