1. Suppose you want to implement an ADT in which you can insert values and retrieve or
remove the item with smallest value. (This ADT is called a priority queue). If forced to choose
between an array implementation and a linked list implementation, which would you choose and
why?
2. Write a recursive function that reads a list of integers from the console and prints them in
reverse order. The function should read until a negative number is encountered. You may only
use one local variable of type int. (So arrays or other aggregate data types are allowed.)
Example: 4 5 6 7 8 9 10 -1
10 9 8 7 6 5 4
3. Repeat question 2 using a local stack rather than recursion.
Solution
import java.util.Scanner;
class Value
{
String name;
int priority;
/** Constructor **/
public Value(String name, int priority)
{
this.name = name;
this.priority = priority;
}
/** toString() **/
public String toString()
{
return \"Value Name : \"+ name +\"\ Priority : \"+ priority;
}
}
/** Class PQ **/
class PQ
{
private Value[] SortedArray;
private int Size, Limit;
/** Constructor **/
public PQ(int Limit)
{
this.Limit = Limit + 1;
SortedArray = new Value[this.Limit];
Size = 0;
}
/** function to clear **/
public void clear()
{
SortedArray = new Value[Limit];
Size = 0;
}
/** function to check if empty **/
public boolean isEmpty()
{
return Size == 0;
}
/** function to check if full **/
public boolean isFull()
{
return Size == Limit - 1;
}
/** function to get Size **/
public int size()
{
return Size;
}
/** function to insert task **/
public void insert(String name, int priority)
{
Value Temp = new Value(name, priority);
SortedArray[++Size] = Temp;
int pos = Size;
while (pos != 1 && Temp.priority > SortedArray[pos/2].priority)
{
SortedArray[pos] = SortedArray[pos/2];
pos /=2;
}
SortedArray[pos] = Temp;
}
/** function to remove task **/
public Value remove()
{
int p, c;
Value item, temp;
if (isEmpty() )
{
System.out.println(\"array is empty\");
return null;
}
temp = SortedArray[1];
item = SortedArray[Size--];
p = 1;
c = 2;
while (c <= Size)
{
if (c < Size && SortedArray[c].priority >SortedArray[c + 1].priority)
c++;
if (temp.priority <=SortedArray[c].priority)
break;
SortedArray[p] = SortedArray[c];
p = c;
c *= 2;
}
SortedArray[p] = temp;
return item;
}
}
public class PQTest
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
PQ pq = new PQ(4 );
pq.insert(\"A\",1);
pq.insert(\"B\",2);
pq.insert(\"C\",10);
pq.insert(\"D\",94);
System.out.println(\"Value A(32),B(2),C(1),D(94) inserted\ \");
System.out.println(\"Value removed \"+pq.remove());
}
}
====================================================
Output:
akshay@akshay-Inspiron-3537:~/Chegg$ javac PQTest.java
akshay@akshay-Inspiron-3537:~/Chegg$ java PQTest
Value A(32),B(2),C(1),D(94) inserted
Value removed Value Name : A
Priority : 1
==========================================================
import java.util.*;
public class reverse {
public static void main(String[] args) {
Stack stack = new Stack();
System.
1. Suppose you want to implement an ADT in which you can insert valu.pdf
1. 1. Suppose you want to implement an ADT in which you can insert values and retrieve or
remove the item with smallest value. (This ADT is called a priority queue). If forced to choose
between an array implementation and a linked list implementation, which would you choose and
why?
2. Write a recursive function that reads a list of integers from the console and prints them in
reverse order. The function should read until a negative number is encountered. You may only
use one local variable of type int. (So arrays or other aggregate data types are allowed.)
Example: 4 5 6 7 8 9 10 -1
10 9 8 7 6 5 4
3. Repeat question 2 using a local stack rather than recursion.
Solution
import java.util.Scanner;
class Value
{
String name;
int priority;
/** Constructor **/
public Value(String name, int priority)
{
this.name = name;
this.priority = priority;
}
/** toString() **/
public String toString()
{
return "Value Name : "+ name +" Priority : "+ priority;
}
2. }
/** Class PQ **/
class PQ
{
private Value[] SortedArray;
private int Size, Limit;
/** Constructor **/
public PQ(int Limit)
{
this.Limit = Limit + 1;
SortedArray = new Value[this.Limit];
Size = 0;
}
/** function to clear **/
public void clear()
{
SortedArray = new Value[Limit];
Size = 0;
}
/** function to check if empty **/
public boolean isEmpty()
{
return Size == 0;
}
/** function to check if full **/
public boolean isFull()
{
return Size == Limit - 1;
}
/** function to get Size **/
public int size()
{
return Size;
}
3. /** function to insert task **/
public void insert(String name, int priority)
{
Value Temp = new Value(name, priority);
SortedArray[++Size] = Temp;
int pos = Size;
while (pos != 1 && Temp.priority > SortedArray[pos/2].priority)
{
SortedArray[pos] = SortedArray[pos/2];
pos /=2;
}
SortedArray[pos] = Temp;
}
/** function to remove task **/
public Value remove()
{
int p, c;
Value item, temp;
if (isEmpty() )
{
System.out.println("array is empty");
return null;
}
temp = SortedArray[1];
item = SortedArray[Size--];
p = 1;
c = 2;
while (c <= Size)
{
if (c < Size && SortedArray[c].priority >SortedArray[c + 1].priority)
c++;
if (temp.priority <=SortedArray[c].priority)
break;
4. SortedArray[p] = SortedArray[c];
p = c;
c *= 2;
}
SortedArray[p] = temp;
return item;
}
}
public class PQTest
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
PQ pq = new PQ(4 );
pq.insert("A",1);
pq.insert("B",2);
pq.insert("C",10);
pq.insert("D",94);
System.out.println("Value A(32),B(2),C(1),D(94) inserted ");
System.out.println("Value removed "+pq.remove());
}
}
====================================================
Output:
akshay@akshay-Inspiron-3537:~/Chegg$ javac PQTest.java
akshay@akshay-Inspiron-3537:~/Chegg$ java PQTest
Value A(32),B(2),C(1),D(94) inserted
Value removed Value Name : A
Priority : 1
5. ==========================================================
import java.util.*;
public class reverse {
public static void main(String[] args) {
Stack stack = new Stack();
System.out.println("Enter elements");
Scanner sc=new Scanner(System.in);
int num;
while((num=sc.nextInt())>0)
{
stack.push(num);
}
System.out.println("Elements in reverse order");
reverseStack(stack);
for (int i = 0, n = stack.size(); i < n; i++) {
System.out.println(stack.elementAt(i));
}
}
public static void reverseStack(Stack stack) {
if (stack.isEmpty()) {
return;
}
T bottom = popBottom(stack);
reverseStack(stack);
stack.push(bottom);
}
private static T popBottom(Stack stack) {
T top = stack.pop();
if (stack.isEmpty()) {
return top;
} else {
T bottom = popBottom(stack);