Thread: having problem on creating this shortest job first nonpreemptive algorithm

Do you have to use parallel arrays to hold the data or can you create a class to hold the data, put instances of the class in an array and sort them?

If the data is in a class, and instances of the class are in an array
what do you want to do with the contents of the array?
Something like:
Select one item from the array based on criteria one.
Sort the remainder of the items in the array based on criteria two.

Ok, now define the class, create a list of instances of the class in a container and look at finding the instance of the class with the first criteria.

regarding on my sorting problem here's what i've done. i've sorted it through its burst time so this is what i do
it'll be sorted from the least burst time to the highest bursttime.

import java.util.*;
public class SHORTESTJOBFIRST_NP_FINAL{
public static void main(String[]args)
{
Scanner in = new Scanner(System.in);
System.out.print("Enter Number of Process: ");
int process = in.nextInt();
String name[] = new String[process];
int BurstT[] = new int[process];
int ArrivalT[] = new int[process];
for(int x = 0; x<process; x++)
{
System.out.print("Name of process: ");
name[x] = in.next();
System.out.print("Enter BurstTime: ");
BurstT[x] = in.nextInt();
System.out.print("Enter ArrivalT: ");
ArrivalT[x] = in.nextInt();
}
System.out.print("\f");
System.out.println("**************[USER INPUTTED VALUES]**************");
System.out.println("============================== ====================");
System.out.println("||\tPROCESS\t||\tBT\t||\tAT\t| |");
System.out.println("============================== ====================");
for(int x=0;x!=process;x++) {
System.out.println("||\t" + name[x] + "\t||\t" + BurstT[x] + "\t||\t" + ArrivalT[x] + "\t||");
}
System.out.println("============================== ====================");
int tempAT, tempBT;
String tempname;
boolean check = false;
 
do{
check=false;
for (int i=0;i < (process-1); i++){
if (BurstT[i] > BurstT[i+1]){
tempAT=ArrivalT[i];
ArrivalT[i]=ArrivalT[i+1];
ArrivalT[i+1]=tempAT;
 
tempBT=BurstT[i];
BurstT[i]=BurstT[i+1];
BurstT[i+1]=tempBT;
 
tempname= name[i];
name[i]= name[i+1];
name[i+1]=tempname;
 
check=true;
}
}
}while(check);
System.out.println("*********[AFTER SORTING INPUTTED VALUES]**********");
System.out.println("============================== ====================");
System.out.println("||\tPROCESS\t||\tBT\t||\tAT\t| |");
System.out.println("============================== ====================");
for(int x=0;x!=process;x++) {
System.out.println("||\t" + name[x] + "\t||\t" + BurstT[x] + "\t||\t" + ArrivalT[x] + "\t||");
}
System.out.println("============================== ====================");
System.out.println();
double sumBT = 0;
//nevermind this computing for the waiting time coz i'm still not finished in this
System.out.println("Computing for Waiting Time: ");
for(int x=0;x!=process;x++)
{
System.out.println(name[x]+" = "+BurstT[x]+" - "+ArrivalT[x]);
}
System.out.println("Turn Around Time(TAT) for each processes: ");
for(int x=0;x!=process;x++)
{
System.out.println(name[x]+" = "+BurstT[x]);
}
 
 
for(int x=0;x!=process;x++)
{
sumBT +=BurstT[x];
}
System.out.printf("Average Turn Around Time(ATAT): %5.2f ms",(sumBT/process));
}
}

now what i nid it to do is get 1 process that has the very least arrival time because that's where the process will start and then display it on the top, and then i'll sort the rest by regarding on their BurstTime from lowest to highest.
//sorry i'm not good in explaining so i'll just visualize what i want to say.

i'll say if i input this:
**************[USER INPUTTED VALUES]**************
==================================================
|| PROCESS || BT || AT ||
==================================================
|| p1 || 8 || 4 ||
|| p2 || 10 || 1 ||
|| p3 || 2 || 2 ||
|| p4 || 7 || 3 ||
|| p5 || 4 || 0 ||
==================================================

this will be the result but then
*********[AFTER SORTING INPUTTED VALUES]**********
==================================================
|| PROCESS || BT || AT ||
==================================================
|| p3 || 2 || 2 ||
|| p5 || 4 || 0 ||
|| p4 || 7 || 3 ||
|| p1 || 8 || 4 ||
|| p2 || 10 || 1 ||
==================================================

I want it to be like this.
==================================================
|| PROCESS || BT || AT ||
==================================================
|| p5 || 4 || 0 || <==== where in first is i'll get the lowest ArrivalTime then display it on top of the sorted list
|| p3 || 2 || 2 || <==== and then the rest is sorted via their BurstTime and it'll be lowest to highest BurstTime
|| p4 || 7 || 3 ||
|| p1 || 8 || 4 ||
|| p2 || 10 || 1 ||
==================================================

can somebody help me ? please?

Please edit your post and format the code with proper indentations. The source statements should not all start in the first column. Unformatted code is hard to read and understand.

i've sorted it through its burst time so this is what i do
it'll be sorted from the least burst time to the highest bursttime.

After sorting on BT you need to find the lowest AT and put that at the front.

Are you having a problem to search through an array for the lowest value in the array?
One technique is to assume the first item in the array is the smallest and then to compare all the other elements against that one to find a smaller one. When a smaller one is found, use it to compare against the rest of the elements looking for a smaller one. Continue to the end of the array.