// moves all the elements between start and end including start and

end to the index of newStart and moves the element in newStart to

after the element of end,

Queue x = {1, 2, 3, 4, 5, 6}; moveTo(x, 1, 3, 0) // can’t move to

anywhere between

1=<newStart<3

Here we chose the indexes 1-3 which is {2, 3, 4} to move to index 0

which is {1}

So after using the method x will be: x = {2, 3, 4, 1, 5, 6}

Let x = {1, 2, 3, 4, 5, 6}

To move the chosen indexes to the last index the newStart should be
equal to

((sizeQ(x)-1)-((end)- (start))) in this case 3 so to move {2, 3, 4} to the

last index the operation will look like this moveTo(x, 1, 3, 3) it’ll result
in x = {1, 5, 6, 2, 3, 4}

public static <T> void moveTo(Queue<T> q, int start, int end, int
newStart) {

if(newStart == sizeQ(q)){
if (start == end) {
return;
}
Queue<T> tempQueue = new Queue<>();
Queue<T> movedElements = new Queue<>();

for (int i = 0; i < start; i++) {

tempQueue.insert(q.remove());
}
for (int i = start; i <= end; i++) {
movedElements.insert(q.remove());
}
while (!q.isEmpty()) {
tempQueue.insert(q.remove());
}
while (!movedElements.isEmpty()) {
tempQueue.insert(movedElements.remove());
 }

while (!tempQueue.isEmpty()) {
q.insert(tempQueue.remove());
}
}else {
Queue<T> temp = new Queue<>();
Queue<T> moved = new Queue<>();

int i = 0;
while (i < start) {
temp.insert(q.remove());
i++;
}

i = start;
while (i <= end) {
moved.insert(q.remove());
i++;
}

while (!q.isEmpty()) {
temp.insert(q.remove());
}

i = 0;
while (i < newStart) {
q.insert(temp.remove());
i++;
}

while (!moved.isEmpty()) {
q.insert(moved.remove());
}

while (!temp.isEmpty()) {
q.insert(temp.remove());
}
}
}
// creates a Queue of integers with the indexes at which there is val in
the Queue

x = {1, 2, 3, 4, 1}; Queue<Integer> y = OcValQ(x, 1); = {0, 4}

public static <T> Queue<Integer> OcValQ(Queue<T> q, T val) {

Queue<Integer> indices = new Queue<>();
Queue<T> tempQueue = copyQ(q);
int count = 0;

while (!tempQueue.isEmpty()) {
T element = tempQueue.remove();
if (element.equals(val)) {
indices.insert(count);
}
count++;
}

return indices;
}
// removes every of the None first Occurrences of any value in a Q,

X = {1, 2, 3, 4, 1} removeNonFirstOccurrencesQ(x) results in x = {1, 2,

3, 4}
public static <T> void removeNonFirstOccurrencesQ(Queue<T>
queue) {
if (queue.isEmpty()) return;

Queue<T> uniqueElements = new Queue<>();

Queue<T> tempQueue = new Queue<>();

while (!queue.isEmpty()) {
T current = queue.remove();
if (!containsElementQ(uniqueElements, current)) {
uniqueElements.insert(current);
tempQueue.insert(current);
}
}

while (!tempQueue.isEmpty()) {
queue.insert(tempQueue.remove());
}
}
// inserts chosen value at chosen index, x = {1, 2, 3, 4}; insertQ(x, 0,
4) results in

x = {4, 1, 2, 3, 4}

public static <T> void insertQ(Queue<T> queue, int index, T value) {

Queue<T> tempQueue = new Queue<>();
int currentIndex = 0;
boolean inserted = false;

while (!queue.isEmpty()) {
if (currentIndex == index) {
tempQueue.insert(value);
inserted = true;
}
tempQueue.insert(queue.remove());
currentIndex++;
}
if (index >= currentIndex) {
tempQueue.insert(value);
inserted = true;
}
if (!inserted) {
tempQueue.insert(value);
}
while (!tempQueue.isEmpty()) {
queue.insert(tempQueue.remove());
}
}
// sets the value at a specific index of a queue, x = {1, 2}; setQ(x, 0,
4); x = {4, 2}

public static <T> void setQ(Queue<T> queue, int index, T value) {

Queue<T> tempQueue = new Queue<>();
int i = 0;

while (i <= index && !queue.isEmpty()) {

T current = queue.remove();
if (i == index) {
current = value;
}
tempQueue.insert(current);
i++;
}
while (!queue.isEmpty()) {
tempQueue.insert(queue.remove());
}
while (!tempQueue.isEmpty()) {
queue.insert(tempQueue.remove());
}
}
// gets the value at a specific index of a queue, x = {1, 2}; int y =
getQ(x, 0); y = 1
public static <T> T getQ(Queue<T> queue, int index) {
int size = 0;
Queue<T> tempQueue = new Queue<>();
T result = null;
while (!queue.isEmpty()) {
T current = queue.remove();
tempQueue.insert(current);
size++;
if (size == index + 1) {
result = current;
}
}
while (!tempQueue.isEmpty()) {
queue.insert(tempQueue.remove());
}
return result;
}

// creates a copy of another Queue, x = {1, 2, 3, 4} Queue<Integer> y

= copyQ(x) = x

public static <T> Queue<T> copyQ(Queue<T> originalQueue) {

Queue<T> copy = new Queue<>();
Queue<T> tempQueue = new Queue<>();
while (!originalQueue.isEmpty()) {
T element = originalQueue.remove();
copy.insert(element);
tempQueue.insert(element);
}
while (!tempQueue.isEmpty()) {
originalQueue.insert(tempQueue.remove());
}
return copy;
}
// deletes a specific index of a Queue, x = {1, 2, 3, 4}; deleteQ(x, 0);

results in x = {2, 3, 4}
public static <T> void deleteQ(Queue<T> queue, int index) {

Queue<T> tempQueue = new Queue<>();

int currentIndex = 0;

while (!queue.isEmpty()) {
if (currentIndex != index) {
tempQueue.insert(queue.remove());
} else {
queue.remove();
}
currentIndex++;
}

while (!tempQueue.isEmpty()) {
queue.insert(tempQueue.remove());
}
}

//gets the size of a Queue, x = {1, 2, 3, 4}; sizeQ(x) = 4

public static <T> int sizeQ(Queue<T> x) {
Queue<T> tempQueue = new Queue<T>();
Queue<T> tempQueue2 = new Queue<T>();

while(!x.isEmpty()){
tempQueue.insert(x.head());
tempQueue2.insert(x.remove());
}
while (!tempQueue2.isEmpty()){
x.insert(tempQueue2.remove());
}
int size = 0;

while (!tempQueue.isEmpty()) {
tempQueue.remove();
size++;
}

return size;
}

//checks if a Queue contains a specific value

public static <T> boolean containsValQ(Queue<T> queue, T value) {
Queue<T> tempQ = copyQ(queue);

while (!tempQ.isEmpty()) {
if (tempQ.remove().equals(value)) {
return true;
}
}
return false;
}

// reverses a Queue

public static <T> void reverseQ(Queue<T> queue) {

if (queue.isEmpty() || queue == null) return;
 T x = queue.remove();
reverseQ(queue);
queue.insert(x);
}

// checks if a Queue is a sub queue of another queue, x = {1, 2, 3, 4};

y = {2, 3};

subQ(x, y) = true, subQ(y, x) = false, whole of x isn’t a part of y

public static <T> boolean subQ(Queue<T> x, Queue<T> y) {

if (y.isEmpty())return true;

if (x.isEmpty() || sizeQ(x) < sizeQ(y)) return false;

Queue<T> tempX = copyQueueQ(x);

Queue<T> tempY = copyQueueQ(y);

while (!tempX.isEmpty()) {
T elementX = tempX.remove();
T elementY = tempY.head();

if (elementX.equals(elementY)) {
tempY.remove();
if (tempY.isEmpty()) {
return true;
}
} else {
tempY = copyQueueQ(y);
}
}
return false;
}

// counts how many times there is a chosen value in a Queue, x = {1,

2, 1}
int value = countOccQ(x, 1) = 2
public static <T> int countOccQ(Queue<T> queue, T value) {
int count = 0;
Queue<T> tempQueue = new Queue<>();

while (!queue.isEmpty()) {
T current = queue.remove();
if (current.equals(value)) {
count++;
}
tempQueue.insert(current);
}
while(!tempQueue.isEmpty()) queue.insert(tempQueue.remove());
return count;
}

//creates a reversed version of a Queue, x = {1, 2, 3, 4};

Queue<Integer> y = reverseA(x) = {4, 3, 2, 1}

public static <T> Queue<T> reverseA(Queue<T> queue) {

Queue<T> temp = copyQ(queue);
Queue<T> reversedQueue = new Queue<>();
reverseQB(temp, reversedQueue);
return reversedQueue;
}

public static <T> void reverseQB(Queue<T> queue, Queue<T>

reversedQueue) {
if (queue.isEmpty()) {
return;
}

T element = queue.remove();
reverseQB(queue, reversedQueue);
reversedQueue.insert(element);
}

//checks if a Queue is a palindrome a word, phrase, or sequence that

reads the same backward as forward
public static <T> boolean isPalindrome(Queue<T> queue) {
if (queue.isEmpty() || sizeQ(queue) == 1) {
return true;
}

Queue<T> reversedQueue = reverseA(queue);

while (!queue.isEmpty()) {
T frontElement = queue.remove();
T reversedElement = reversedQueue.remove();

if (!frontElement.equals(reversedElement)) {
return false;
}
}

return true;
}

//removes only the none first consecutive occurrences of every value in

a Queue
After using the method on x = {1, 1, 2, 3, 2, 2, 1}, x will be {1, 2, 3, 2,
1}

public static <T> void removeConsecutiveOccurrencesQ(Queue<T>

queue) {
if (queue.isEmpty() || sizeQ(queue) == 1) return;

Queue<T> tempQueue = new Queue<>();

T prev = queue.remove();
tempQueue.insert(prev);

while (!queue.isEmpty()) {
T current = queue.remove();
if (!current.equals(prev)) {
tempQueue.insert(current);
prev = current;
}
}
while (!tempQueue.isEmpty()) {
queue.insert(tempQueue.remove());
}
}

// deletes every index of a Node at which there is a specific value at.

public static <T> void deleteQT(Queue<T> head, T value) {

for(int i = 0; i<sizeQ(head); i++){

if(getQ(head, i) == value) {

deleteQ(head, i);

i--;

}
// splits a Queue into a Queue of Queues with the sizeQ of n,

Queue<Integer> x = {1, 2, 3, 4, 5}, Queue<Queue<Integer>> y =

split(x, 4)

results in y = {{1, 2}, {3}, {4}, {5}}

Another example: Queue<Integer> x = {1, 2, 3, 4, 5};

Queue<Queue<Integer>> y = split(x, 2); results in y = {{1, 2, 3}, {4,

5}}

public static <T> Queue<Queue<T>> splitQ(Queue<T> q, int n) {

if (q.isEmpty() || n <= 0) return null;

int size = sizeQ(q);

int partSize = size / n;
int remainder = size % n;

Queue<Queue<T>> resultQueue = new Queue<>();

Queue<T> currentPart = null;

for (int i = 0; i < n; i++) {

currentPart = new Queue<>();
int currentPartSize = partSize + (i < remainder ? 1 : 0);

for (int j = 0; j < currentPartSize; j++) {

if (!q.isEmpty()) {
currentPart.insert(q.remove());
}
}

resultQueue.insert(currentPart);
}

return resultQueue;
}
//creates a Queue which is the sorted version of queue

public static Queue<Integer> sortQ(Queue<Integer> queue) {

Queue<Integer> sortedQueue = new Queue<>();

while (!queue.isEmpty()) {
int current = queue.remove();
Queue<Integer> tempQueue = new Queue<>();
boolean inserted = false;

while (!sortedQueue.isEmpty()) {
int value = sortedQueue.remove();
if (!inserted && current < value) {
tempQueue.insert(current);
inserted = true;
}
tempQueue.insert(value);
}
if (!inserted) {
tempQueue.insert(current);
}
while (!tempQueue.isEmpty()) {
sortedQueue.insert(tempQueue.remove());
}
}
return sortedQueue;
}
//The method takes the selected Queue(queue) and will create a new
splited Queue out of it according the the chosen start and end. for
example:

A = {1, 2, 3, 4, 5, 6} and B = CSplitQ(A, 1, 3) so it'll result in B = {{1},

{2, 3, 4}, {5 ,6}} because {2, 3, 4} are at indexes 1-3, 2 is at index 1
and 4 is at index 3

B is a Queue<Queue<Integer>> in this example.

public static <T> Queue<Queue<T>> CSplitQ(Queue<T> queue, int

start, int end) {
if (queue.isEmpty() || start > end) return null;

Queue<Queue<T>> resultQueue = new Queue<>();

Queue<T> firstPart = new Queue<>();
Queue<T> middlePart = new Queue<>();
Queue<T> lastPart = new Queue<>();

int index = 0;
while (!queue.isEmpty() && index < start) {
firstPart.insert(queue.remove());
index++;
}

while (!queue.isEmpty() && index <= end) {

middlePart.insert(queue.remove());
index++;
}

while (!queue.isEmpty()) lastPart.insert(queue.remove());

if (!firstPart.isEmpty()) resultQueue.insert(firstPart);
if (!middlePart.isEmpty()) resultQueue.insert(middlePart);
if (!lastPart.isEmpty()) resultQueue.insert(lastPart);

return resultQueue;
}
//find the min value in the queue

public static int findMinQ(Queue<Integer> queue) {

if (queue.isEmpty())return 0; // a mistake, it should return nothing

Queue<Integer> tempQueue = new Queue<>();

int min = Integer.MAX_VALUE;

while (!queue.isEmpty()) {
int current = queue.remove();
if (current < min) {
min = current;
}
tempQueue.insert(current);
}
while (!tempQueue.isEmpty())
queue.insert(tempQueue.remove());

return min;
}
//finds the max value in the queue
public static <T> int findMaxQ(Queue<Integer> queue) {
if (queue.isEmpty()) return 0; // a mistake it should return nothing

Queue<Integer> tempQueue = new Queue<>();

int max = Integer.MIN_VALUE;

while (!queue.isEmpty()) {
int current = queue.remove();
if (current > max) {
max = current;
}
tempQueue.insert(current);
}
while (!tempQueue.isEmpty()) queue.insert(tempQueue.remove());

return max;
}
Magnitude of running time, Order of DE via degree of n

1. moveTo = O(n)
2. OcValQ = O(n)
3. removeNoneFirstOccurrencesQ = O(n)
4. insertQ = O(n)
5. setQ = O(n)
6. getQ = O(n)
7. copyQ = O(n)
8. delete = O(n)
9. sizeQ = O(n)
10. containsValueQ = O(n)
11. reverseQ = O(n)
12. subQ = O(n)
13. countOccQ = O(n)
14. reverseA = O(n)
15. isPalindrome = O(n)
16. removeConsecutiveOccurrences = O(n)
17. deleteQT = O(n^2)
18. splitQ = O(n)
19. sortQ = O(n)
20. CSplitQ = O(n)
21. findMinQ = O(n)
22. findMaxQ = O(n)

//How to create a Queue:

Queue<data type> x = new Queue<>();

How to add values to the Queue:

(Name of Queue).insert(value of same data type of the Queue)

Queue<Integer> x = new Queue<>();

x.insert(1) – index 0

x.insert(2) – index 1
// The Queue class:

public boolean isEmpty() {

return this.first == null;
}
public void insert(T x) {
if (this.first == null) {
this.first = new Node(x);
this.lastPos = this.first;
} else {
this.lastPos.setNext(new Node(x));
this.lastPos = this.lastPos.getNext();
}
}
public T remove() {
T x = this.first.getValue();
Node<T> pos = this.first;
this.first = this.first.getNext();
if (this.first == null) {
this.lastPos = null;
}
pos.setNext((Node)null);
return x;
}
public T head() {
return this.first.getValue();
}
public String toString() {
Node<T> pos = this.first;

String str;
for(str = "["; pos != null; pos = pos.getNext()) {
str = str + pos.getValue().toString();
if (pos.getNext() != null) {
str = str + ",";
}
}
str = str + "]";
return str;
}