0

Ok so it was easy to implement a circular queue with an array.

Here I have code which tries to implement a circular queue using an arraylist. the problem is that even though i have implemented my deque and enque methods this does not work with my arraylist(however this works with a normal array)....

Unlike an array if i use this code on my arraylist it seems to be removing and adding wrongly at different positionns

import java.util.*;

public class People {

    private final int DEFAULT_CAPACITY = 100;
    private int front, rear, count;
    private ArrayList<thePeople> people;
    private int theMaxCapacity;

    //-----------------------------------------------------------------
    //  Creates an empty queue using the specified capacity.
    //-----------------------------------------------------------------
    public People(int initialCapacity) {
        front = rear = count = 0;
        people = new ArrayList<thePeople>(Collections.nCopies(5, (thePeople) null));

    }

    //-----------------------------------------------------------------
    //  Adds the specified element to the rear of the queue, expanding
    //  the capacity of the queue array if necessary.
    //-----------------------------------------------------------------
    public void enque(thePeople element) {
        if (this.isFull()) {
            System.out.println("Queue Full");

            System.exit(1);
        } else {
            people.set(rear, element);
            rear = rear + 1;
            if (rear == people.size()) {
                rear = 0;
            }
            count++;
        }
    }

    //-----------------------------------------------------------------
    //  Removes the element at the front of the queue and returns a
    //  reference to it. Throws an EmptyCollectionException if the
    //  queue is empty.
    //-----------------------------------------------------------------
    public thePeople dequeue() {
        if (isEmpty()) {
            System.out.println("Empty Queue");
        }

        thePeople result = people.get(front);
        people.set(front, null);

        front = (front + 1) % people.size();

        count--;

        return result;
    }

    //-----------------------------------------------------------------
    //  Returns true if this queue is empty and false otherwise. 
    //-----------------------------------------------------------------
    public boolean isEmpty() {
        return (count == 0);
    }

    //-----------------------------------------------------------------
    //  Returns the number of elements currently in this queue.
    //-----------------------------------------------------------------
    public int size() {
        return count;
    }

    public boolean isFull() {

        return count == people.size();
    }

    public void mySimulation() {
        Random rand1 = new Random();
        thePeople theM = null;

        if (this.isFull()) {
            this.people.remove(0);
            System.out.println("Enqueueing...");
            this.enque(people.get(rand1.nextInt(people.size())));
            thePeople r1 = people.get(rear - 1);
            System.out.println(people.toString());
            System.out.println(r1);
            for (int e = 0; e < people.size(); e++) {
                if (people.get(e) instanceof thePeople) {
                    System.out.println("G");
                } else {
                    System.out.println("D");
                }
            }

        }

    }

    //-----------------------------------------------------------------
    //  Returns a string representation of this queue. 
    //-----------------------------------------------------------------
    @Override
    public String toString() {
        String result = "";
        int scan = 0;

        while (scan < count) {
            if (people.get(scan) != null) {
                result += people.get(scan).toString() + "\n";
            }
            scan++;
        }

        return result;

    }

    public static void main(String[] args) {
        People Q1 = new People(25);
        thePeople call1 = new thePeople("John King", "001 456 789");
        thePeople call2 = new thePeople("Michael Fish", "789 654 321");

        Q1.enque(call1);
        Q1.enque(call2);

        System.out.println(Q1.toString());
        ArrayList<thePeople> callerDetails = new ArrayList<>(Arrays.asList(call1, call2));
        Random rand = new Random();
        for (int z = 0; z <= 4; z++) {
            Q1.enque(callerDetails.get(rand.nextInt(callerDetails.size())));

        }
        System.out.println(Q1.toString());

    }

}

my question is that how can I modify the enque and deque methods to work with an araylist(a circular queue arraylist) ?

1
  • 1
    The basic idea of using an arraylist to implement a circular queue is broken. If this is a school assignment, it's s silly one, and I'm sorry you're required to do it. If this is a real application, use ArrayDeque. Commented Dec 11, 2016 at 19:30

1 Answer 1

2

I have made some changes to your code see if it helps you.

import java.util.*;

public class People {

    private final int DEFAULT_CAPACITY = 100;
    private int front, rear, count;
    private ArrayList<thePeople> people;
    private int theMaxCapacity;

    //-----------------------------------------------------------------
    //  Creates an empty queue using the specified capacity.
    //-----------------------------------------------------------------
    public People(int initialCapacity) {
        front = rear = count = 0;
        people = new ArrayList<thePeople>();

    }

    //-----------------------------------------------------------------
    //  Adds the specified element to the rear of the queue, expanding
    //  the capacity of the queue array if necessary.
    //-----------------------------------------------------------------
    public void enque(thePeople element) {
        if (this.isFull()) {
            System.out.println("Queue Full");
            System.exit(1);
        } else {
            people.add(element);           
        }
    }

    //-----------------------------------------------------------------
    //  Removes the element at the front of the queue and returns a
    //  reference to it. Throws an EmptyCollectionException if the
    //  queue is empty.
    //-----------------------------------------------------------------
    public thePeople dequeue() {
        if (isEmpty()) {
            System.out.println("Empty Queue");
        }

        thePeople result = people.get(0);  
        people.remove(0);                      

        return result;
    }

    //-----------------------------------------------------------------
    //  Returns true if this queue is empty and false otherwise. 
    //-----------------------------------------------------------------
    public boolean isEmpty() {
        return (people.size() == 0);
    }

    //-----------------------------------------------------------------
    //  Returns the number of elements currently in this queue.
    //-----------------------------------------------------------------
    public int size() {
        return people.size();
    }

    public boolean isFull() {

        return people.size() == DEFAULT_CAPACITY;
    }

    public void mySimulation() {
        Random rand1 = new Random();
        thePeople theM = null;

        if (this.isFull()) {
            this.people.remove(0);
            System.out.println("Enqueueing...");
            this.enque(people.get(rand1.nextInt(people.size())));
            thePeople r1 = people.get(rear - 1);
            System.out.println(people.toString());
            System.out.println(r1);
            for (int e = 0; e < people.size(); e++) {
                if (people.get(e) instanceof thePeople) {
                    System.out.println("G");
                } else {
                    System.out.println("D");
                }
            }

        }

    }

    //-----------------------------------------------------------------
    //  Returns a string representation of this queue. 
    //-----------------------------------------------------------------
    @Override
    public String toString() {
        String result = "";
        int scan = 0;

        while (scan < count) {
            if (people.get(scan) != null) {
                result += people.get(scan).toString() + "\n";
            }
            scan++;
        }

        return result;

    }

    public static void main(String[] args) {
        People Q1 = new People(25);
        thePeople call1 = new thePeople("John King", "001 456 789");
        thePeople call2 = new thePeople("Michael Fish", "789 654 321");

        Q1.enque(call1);
        Q1.enque(call2);

        System.out.println(Q1.toString());
        ArrayList<thePeople> callerDetails = new ArrayList<>(Arrays.asList(call1, call2));
        Random rand = new Random();
        for (int z = 0; z <= 4; z++) {
            Q1.enque(callerDetails.get(rand.nextInt(callerDetails.size())));

        }
        System.out.println(Q1.toString());

    }

}
Sign up to request clarification or add additional context in comments.

3 Comments

i think this should work, is it possible because i wanted to for this part people.add(element); and same for the deque not use a helper method for instance code that part ... ?
I have edited the answer, forgot to remove the element when dequeuing.
This answer is ok but only it does not take care of the wrap around because am "implementing a circular queue using an arrayList" such as adding rear = (rear+1) % queue.length; and front = (front+1) % queue.length; ..... ?

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.