挑战程序设计竞赛（算法和数据结构）——4.3队列习题的Java实现

题目：


基本思路：
将任务定义为一个包含名称和时间的Task类，定义一个Task类型的队列，并循环下列算法：
用时间sum_time来记录处理情况，只要队列不为空，就不断执行
当处理一个队头任务时，首先判断其任务时间是否小于等于0 ，是则出队，否则分为两种情况：
1.任务时间>最大处理时间，首先用temp记录该对象并出队，接着对temp的时间调整为原任务时间-最大处理时间，最后将该temp入队至队尾；sum_time+=100
2.任务时间<=最大处理时间，sum_time+=对象时间，并打印对象的名称和时间；队头出队。

代码如下：

import java.io.BufferedInputStream;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class QueueMain {
    public static void main(String[] args) {
        //声明一个任务类
        class Task{
            String name;
            int time;
        }

        //定义一个Task类的队列
        Queue<Task> queue = new LinkedList<Task>();

        Scanner cin = new Scanner(new BufferedInputStream(System.in));
        System.out.println("输入任务数：");
        int capacity = cin.nextInt();
        System.out.println("输入CPU最大处理时间：");
        int q = cin.nextInt();
        for(int i=0;i<capacity;i++){
            Task newTask = new Task();
            System.out.println("输入 名称 和 任务时间 ：");
            newTask.name = cin.next();
            newTask.time = cin.nextInt();
            queue.offer(newTask);
        }

        /*
        思路：用一个时间sum_time来记录处理情况，只要队列不为空，就不断执行
        当处理一个队头任务时，首先判断其任务时间是否小于等于0 ，是则出队，否则分为两种情况：
        1.任务时间>最大处理时间，首先用temp记录该对象并出队，接着对temp的时间调整为原任务时间-最大处理时间，最后将该temp入队至队尾；sum_time+=100
        2.任务时间<=最大处理时间，sum_time+=对象时间，并打印对象的名称和时间；队头出队。
         */
        int sum_time = 0;

        while (queue.size()>0){
            if(queue.element().time<=0){
                queue.poll();
            }
            else{
                if(queue.element().time>q){
                    Task temp = queue.element();
                    temp.time = queue.element().time-q;
                    queue.poll();
                    queue.offer(temp);
                    sum_time += q;
                }
//                2.任务时间<=最大处理时间，sum_time+=对象时间，并打印对象的名称和sum_time；队头出队。
                else if(queue.element().time<=q){
                    sum_time += queue.element().time;
                    System.out.println(queue.element().name + " " + sum_time);
                    queue.poll();
                }
            }
        }
    }
}

——————————————————
附数组队列和链式队列的java代码实现：

public class ArrayQueue {
    int front, rear, size;//size记录当前多少元素，front队头指针让数据出去，rear队尾指针让数据进来
    int capacity;
    int array[];

    public ArrayQueue(int capacity){
        this.capacity = capacity;//队列的容量是一定的
        front = rear = size = 0;//
        array = new int[capacity];
    }

    //入队操作
    public void enqueue(int item){
        if(isFull())return;//队列满了就直接返回空，否则执行下列代码
        array[rear] = item;//队尾添加元素
        rear = (rear+1) % capacity;//更新队尾指针
        size++;//元素个数多了一个
//        System.out.println(item + "is enqueued.");
    }

    //出队操作
    public int dequeue(){//同理入队，出队的代码操作反着来，处理的指针是队头指向
        if(isEmpty())return Integer.MIN_VALUE;
        int item = array[front];
        front = (front+1)%capacity;
        size--;
        return item;
    }

    //获取队列当前队头元素
    public  int peek(){
        if(isEmpty())return Integer.MIN_VALUE;
        return array[front];
    }
    //判断队列是否满了
    public boolean isFull(){
        return size == capacity;
    }

    //判断队列是否空了
    public boolean isEmpty(){
        return size ==0;
    }
}

public class ListQueue {

    QueueNode front;//链式队列记录队头节点
    QueueNode rear;//链式队列记录队尾节点

    static  class QueueNode{
        int value;//每一个节点记录值
        QueueNode next;//节点记录下一个节点的指针
        public QueueNode(int value){
            this.value = value;
        }
    }

    public void enqueue(int value){
        QueueNode newNode = new QueueNode(value);
        if (this.rear == null) {//队列是空的，则队头队尾指向同一个元素
            this.front=this.rear=newNode;
            return;
        }
        this.rear.next = newNode;//让尾节点的下一个节点指向新节点
        this.rear = newNode;//并让新节点作为尾节点
    }

    public int dequeue(){
        if(this.front==null){
            System.out.println("The queue is empty.");
            return Integer.MIN_VALUE;
        }
        QueueNode frontNode = this.front;//只要队列不为空，就拿到头节点，输出节点值即可
        this.front = this.front.next;//头节点更新为指向的节点
        if(this.front==null){
            this.rear = null;
        }
        return frontNode.value;
    }
}

作于：
2021-11-07
13:22:53
修改于：
2021-11-8