队列

队列应用：代码密钥

 

1.具体实现时给出泛型的具象本例为偏移量KEY所以是Integer类型

2.用charAt()取出单个字符，强制转型为int与偏移量相加.再强转回char

public static void main ( String[] args) { int[] key = {5, 12, -3, 8, -9, 4, 10}; Integer keyValue; String encoded = "", decoded = ""; String message = "All programmers are playwrights and all " + "computers are lousy actors."; CircularArrayQueue<Integer> keyQueue1 = new CircularArrayQueue<Integer>(); CircularArrayQueue<Integer> keyQueue2 = new CircularArrayQueue<Integer>(); /** load key queue */ for (int scan=0; scan < key.length; scan++) { keyQueue1.enqueue (new Integer(key[scan])); keyQueue2.enqueue (new Integer(key[scan])); } /** encode message */ for (int scan=0; scan < message.length(); scan++) { keyValue = keyQueue1.dequeue(); encoded += (char) ((int)message.charAt(scan) + keyValue.intValue()); keyQueue1.enqueue (keyValue); } System.out.println ("Encoded Message:/n" + encoded + "/n"); /** decode message */ for (int scan=0; scan < encoded.length(); scan++) { keyValue = keyQueue2.dequeue(); decoded += (char) ((int)encoded.charAt(scan) - keyValue.intValue()); keyQueue2.enqueue (keyValue); } System.out.println ("Decoded Message:/n" + decoded); } 

 

售票口模拟

假定每隔15秒来一位顾客，本例模拟100位顾客

 

 

 

Customer类:

public class Customer { private int arrivalTime, departureTime; /** * Creates a new customer with the specified arrival time. * * @param arrives the integer representation of the arrival time */ public Customer (int arrives) { arrivalTime = arrives; departureTime = 0; } /** * Returns the arrival time of this customer. * * @return the integer representation of the arrival time */ public int getArrivalTime() { return arrivalTime; } /** * Sets the departure time for this customer. * * @param departs the integer representation of the departure time **/ public void setDepartureTime (int departs) { departureTime = departs; } /** * Returns the departure time of this customer. * * @return the integer representation of the departure time */ public int getDepartureTime() { return departureTime; } /** * Computes and returns the total time spent by this customer. * * @return the integer representation of the total customer time */ public int totalTime() { return departureTime - arrivalTime; } }  

 

 

1.多层循环嵌套时循环指针千万不要混淆。

2.初始化工作：

所有cashier的cashierTime均为0,

将100名customer给出其arrivalTime并加入队列.

 

 

3.分别讨论安排数量不同的cashier的时间 顾客消耗的时间.（对应最外层循环）

4.每个客户的总消耗时间 用客户类本身的totalTime()计算.(面向对象的思想)

5.每个客户离开的时间有两种情况

    a.customer.getArrivalTime()>cashierTime[count]

        departs = (PROCESS+custome.getArrivalTime());

    b.customer.getArrivalTime()<cashierTime[count]

        departs = cashier[count]+PROCESS;

6.每个cashierTime[count]设为前一个客户的departsTime

 

TicketCounter类:

public class TicketCounter { final static int PROCESS = 120; final static int MAX_CASHIERS = 10; final static int NUM_CUSTOMERS = 100; public static void main ( String[] args) { Customer customer; LinkedQueue<Customer> customerQueue = new LinkedQueue<Customer>(); int[] cashierTime = new int[MAX_CASHIERS]; int totalTime, averageTime, departs; /** process the simulation for various number of cashiers */ for (int cashiers=0; cashiers < MAX_CASHIERS; cashiers++) { /** set each cashiers time to zero initially*/ for (int count=0; count < cashiers; count++) cashierTime[count] = 0; /** load customer queue */ for (int count=1; count <= NUM_CUSTOMERS; count++) customerQueue.enqueue(new Customer(count*15)); totalTime = 0; /** process all customers in the queue */ while (!(customerQueue.isEmpty())) { for (int count=0; count <= cashiers; count++) { if (!(customerQueue.isEmpty())) { customer = customerQueue.dequeue(); if (customer.getArrivalTime() > cashierTime[count]) departs = customer.getArrivalTime() + PROCESS; else departs = cashierTime[count] + PROCESS; customer.setDepartureTime (departs); cashierTime[count] = departs; totalTime += customer.totalTime(); } } } /** output results for this simulation */ averageTime = totalTime / NUM_CUSTOMERS; System.out.println ("Number of cashiers: " + (cashiers+1)); System.out.println ("Average time: " + averageTime + "/n"); } } } 

 

用单链表实现队列

(末端enqueue前端dequeue)

 

1.进队从队尾进

2.进队时若为空

front = node;

rear = node;

若不为空

rear.setNext(node);

rear = node;

3.出队时定义 T result;将其返回.

4.链式结构里，进队，出队接收，返回的都是泛型T的具象但在加入链式结构之前 用LinearNode<T>对其包装，拆装

/** * LinkedQueue represents a linked implementation of a queue. * * @author Dr. Lewis * @author Dr. Chase * @version 1.0, 08/12/08 */ package jss2; import jss2.exceptions.*; public class LinkedQueue<T> implements QueueADT<T> { private int count; private LinearNode<T> front, rear; /** * Creates an empty queue. */ public LinkedQueue() { count = 0; front = rear = null; } /** * Adds the specified element to the rear of this queue. * * @param element the element to be added to the rear of this queue */ public void enqueue (T element) { LinearNode<T> node = new LinearNode<T>(element); if (isEmpty()) front = node; else rear.setNext (node); rear = node; count++; } /** * Removes the element at the front of this queue and returns a * reference to it. Throws an EmptyCollectionException if the * queue is empty. * * @return the element at the front of this queue * @throws EmptyCollectionException if an empty collection exception occurs */ public T dequeue() throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException ("queue"); T result = front.getElement(); front = front.getNext(); count--; if (isEmpty()) rear = null; return result; } /** * Returns a reference to the element at the front of this queue. * The element is not removed from the queue. Throws an * EmptyCollectionException if the queue is empty. * * @return a reference to the first element in * this queue * @throws EmptyCollectionsException if an empty collection exception occurs */ public T first() throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException ("queue"); return front.getElement(); } /** * Returns true if this queue is empty and false otherwise. * * @return true if this queue is empty and false if otherwise */ public boolean isEmpty() { return (count == 0); } /** * Returns the number of elements currently in this queue. * * @return the integer representation of the size of this queue */ public int size() { return count; } /** * Returns a string representation of this queue. * * @return the string representation of this queue */ public String toString() { String result = ""; LinearNode<T> current = front; while (current != null) { result = result + (current.getElement()).toString() + "/n"; current = current.getNext(); } return result; } }  

 

 

数组实现循环队列

enqueue操作:rear = (rear+1)%queue.length

dequeue操作：front = (front+1)%queue.length

 

1.数组实现的循环队列 包含有T[] queue 的泛型数组.

2.rear指向其下一个可用位置。

3.count计数器记录结构里的element数.

4.当count==queue时需要expandCapacity.

5.expandCapacity();

按从front到rear的顺序将元素复制larger里

新的front = 0,rear = count（及下一个可用位置）

 

public void expandCapacity() { T[] larger = (T[])(new Object[queue.length *2]); for(int scan=0; scan < count; scan++) { larger[scan] = queue[front]; front=(front+1) % queue.length; } front = 0; rear = count; queue = larger; } 

 

6.进队时将element放到queue[rear];rear = (rear+1)%queue.length

7.出队时T result  = queue[front];

别忘了queue[front]=null;

front = (front+1)%queue.length;

8.初始化时T[] queue = (T[])new Object[DEFAULT_CAPACITY]

 

 

 

 

 

public class CircularArrayQueue<T> implements QueueADT<T> { private final int DEFAULT_CAPACITY = 100; private int front, rear, count; private T[] queue; /** * Creates an empty queue using the default capacity. */ public CircularArrayQueue() { front = rear = count = 0; queue = (T[]) (new Object[DEFAULT_CAPACITY]); } /** * Creates an empty queue using the specified capacity. * * @param initialCapacity the integer representation of the initial * size of the circular array queue */ public CircularArrayQueue (int initialCapacity) { front = rear = count = 0; queue = ( (T[])(new Object[initialCapacity]) ); } /** * Adds the specified element to the rear of this queue, expanding * the capacity of the queue array if necessary. * * @param element the element to add to the rear of the queue */ public void enqueue (T element) { if (size() == queue.length) expandCapacity(); queue[rear] = element; rear = (rear+1) % queue.length; count++; } /** * Removes the element at the front of this queue and returns a * reference to it. Throws an EmptyCollectionException if the * queue is empty. * * @return the reference to the element at the front * of the queue that was removed * @throws EmptyCollectionException if an empty collections exception occurs */ public T dequeue() throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException ("queue"); T result = queue[front]; queue[front] = null; front = (front+1) % queue.length; count--; return result; } /** * Returns a reference to the element at the front of this queue. * The element is not removed from the queue. Throws an * EmptyCollectionException if the queue is empty. * * @return a reference to the first element in the * queue * @throws EmptyCollectionException if an empty collections exception occurs */ public T first() throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException ("queue"); return queue[front]; } /** * Returns true if this queue is empty and false otherwise. * * @return returns true if this queue is empty and false if otherwise */ public boolean isEmpty() { return (count == 0); } /** * Returns the number of elements currently in this queue. * * @return the integer representation of the size of this queue */ public int size() { return count; } /** * Returns a string representation of this queue. * * @return the string representation of this queue */ public String toString() { String result = ""; int scan = 0; while(scan < count) { if(queue[scan]!=null) { result += queue[scan].toString()+"/n"; } scan++; } return result; } /** * Creates a new array to store the contents of this queue with * twice the capacity of the old one. */ public void expandCapacity() { T[] larger = (T[])(new Object[queue.length *2]); for(int scan=0; scan < count; scan++) { larger[scan] = queue[front]; front=(front+1) % queue.length; } front = 0; rear = count; queue = larger; } }