Issues with double linked list

Expand Post »

Hey All I am having issues with my code and it has something to do with the way my double linked list is working.

I cant figure out if its not setting the m_prev pointer if at all and what is going on with my m_next pointer. Any help would be greatly appreciated I have been banging my head on the desk for the last 7 hours working on it. I just need to get the pointers working correctly and I think that it will be working correctly.

Just a little bit of background this is a homework project I am working on that is suppose to simulate a operating system scheduler. The main contains a variable that gets used over and over again during input so its contents are always overwritten after the while loop restarts. it is called process. I want to insert into the Startup queue and I thought I had it until I did some cout statements to see what was going on.

Thanks In advanced!!

Here is the complete code:

C++ Syntax (Toggle Plain Text)
//***********************************
// include files
//***********************************
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cctype>
#include <cstdlib>
#include <cmath>
using namespace std;
typedef unsigned char boolean;
 
//***********************************
// define directives
//***********************************
// Directive to store the minimum time slice
#define MIN_TIME_SLICE 10
// Directive to store the maximum time slice
#define MAX_TIME_SLICE 300
// Directive to store the lowest priority (*note* higher number = lower priority)
#define MIN_PRIORITY 140
// Directive to store the highest priority(*note* lower number = higher priority)
#define MAX_PRIORITY 100
// Directive to store the highest nice value(*note* lower number = nicer Process)
#define MAX_NICE = -20
// Directive to store the lowest nice value (*note* higher number = not so nice Process)
#define MIN_NICE = 19
 
//***********************************
// globals
//***********************************
 
// Clock for my scheduler
long myClock;
// Max amount of proccess in the file
int maxProcesses;
// Total turn around time for all Processes
long totalTAT;
// Total wait time for all Processes
long totalWT;
// Total CPU utiliation Time for all Processes
double totalCUT;
// The global count variables that gets used over and over again
int i, j, k;
// The global temp integer variable
int tempInt;
 
// class that defines what a Processes is
class ProcessContents{
	public:
	// constructors
	ProcessContents( );
	ProcessContents(ProcessContents*);
	// values in a process
	int pid;  //pid of Process
	int nice; // Processes nice value
	int arrivalTime;  // Processes arrival time
	int numCPUBursts;  // number of cpu bursts
	int numIOBursts;  // number of i/o bursts = #cpu bursts - 1
	int totalBursts;
	int endTime;  // Processes end time
	int priority;  // priority of Process
	int timeslice;  // Processes timesliceSTRUCT AS A FUNCTION PARAMETER DECLARATION
	int* burst;  // dynamic array of cpu bursts and io bursts for the Process
 
	void insert(ProcessContents*);  
	void setData(ProcessContents*);
	// setters
	ProcessContents* getPrev();
    ProcessContents* getNext();
    void setNext(ProcessContents*);    
	ProcessContents getData();
    int getDataEl();
 
	void reset();
    void prev();
    void next();
    void end();  
 
	//Boolean
    boolean isBeginning();
    boolean isEnd();
    boolean isEmpty();
 
	private:
	ProcessContents *m_next, *m_prev, *m_curr;
 
};
 
 
 
ProcessContents :: ProcessContents() {
  m_prev = NULL;
  m_next = NULL;
  m_curr = this;
  endTime = 0;
  priority = 69;
  timeslice = 143;
  burst = NULL;
}
 
ProcessContents :: ProcessContents(ProcessContents* previous) {
  m_prev = previous;
  cout << " PRINT PREVIOUS " << previous << endl;
  m_next = NULL;
  priority = 96;
 
}
 
void ProcessContents::insert(ProcessContents* pNode) {
  while (m_curr->getNext() != NULL)
    m_curr = m_curr->getNext();
 
  m_curr->setData(pNode);
  cout << "POINTERS: "<< m_curr<< " " << m_next << " " << m_prev << endl;
  m_curr->setNext(new ProcessContents(m_curr)); 
	cout << "POINTERS AFTER: "<< m_curr<< " " << m_next << " " << m_prev << endl;
 
 // creates the link between a newly created list and the current list
}
 
void ProcessContents::setData(ProcessContents* pNode) {
  int z;
  pid = pNode -> pid;
  nice = pNode -> nice;
  arrivalTime = pNode -> arrivalTime;
  numCPUBursts = pNode -> numCPUBursts;
  numIOBursts = pNode -> numIOBursts;
  totalBursts = pNode -> totalBursts;
  endTime = pNode -> endTime;
  priority = pNode -> priority;
  timeslice = pNode -> timeslice; 
  burst = new int[totalBursts]; 
  for (z = totalBursts - 1; z >= 0; z--) {
  burst[z] = pNode -> burst[z];
  }
 
}
 
ProcessContents ProcessContents::getData() {
  cout << "Pid: " << pid << endl;
  cout << "Arrival time: " << arrivalTime << endl;
  cout << "Priority: " << priority << endl;
  cout << "Total Burst: " << totalBursts << endl;
 
}
 
ProcessContents* ProcessContents::getPrev() {
  return m_prev;
}
 
ProcessContents* ProcessContents::getNext() {
  return m_next;
}
 
void ProcessContents::setNext(ProcessContents* link) {
  m_next = link;
}
 
 
void ProcessContents::reset() {
  m_curr = this;
}
 
void ProcessContents::next() {
  m_curr = m_curr->getNext();
}
 
void ProcessContents::prev() {
  m_curr = m_curr->getPrev();
}
 
boolean ProcessContents::isEnd() {
  return m_curr->getNext() == NULL ? 1 : 0;
}
 
boolean ProcessContents::isBeginning() {
  return m_curr == NULL ? 1 : 0; ;
}
 
boolean ProcessContents::isEmpty() {
  return m_curr->getNext() == m_curr->getPrev() ? 1 : 0;
}
 
/*
int Queue :: calculateDynPty(ProcessContents* node){
// have to adjust this part
  node -> priority = (node -> priority) + (-1)*((node -> Bonus) + (node -> priority));
  
  return (node -> priority);
}
 
double Queue :: calculateTimeSlice(ProcessContents *node){
  node -> priority = (int)ceil((-180.0/49.0)*(double)(calculateDynPty(node))+(26900.0/49.0));
  return (node -> priority);
}
 
*/
 
//***********************************
// function definitions
//***********************************
 
// Function that gets all the input from unix file redirection and places them into the startup queue
 
/*
// *****************MOST PRINT STATEMENTS*******************************
// function that prints Arrival Processes in the active queue
void printArrivalActive(Process myProcessIn);
// function that prints when a Process enters the cpu
void printEnterCPU(Process myProcessIn, int time);
// function that prints when a Process is preempted
void printPreempt(Process myProcessIn, Process myProcessOut, int time);
//function that prints when a Process is finsihed with all cpu bursts
void printFinishCPU(Process myProcessOut, int time);
// function that prints when a Process finishes a cpu burst and moves to the I/O queue
void printCPUToIO(Process myProcessOut, int time);
// funcation that prints when a Process finishes its timeslice and moves to the expired queue
void printExpiredTimeslice(Process myProcessOut, int time);
// function that prints when a Process finishes I/O burst and moves to the expired queue
void printIOToExpired(Process myProcessOut, int time);
// function that prints when a Process finishes I/O burst and moves to active queue
void printIOToActive(Process myProcessOut, int time);
// function that prints when the active and expired arrays are swapped
void printSwap(int time);
 
// *****************MOST CALC STATEMENTS********************************
// function that calculates Turn around time for a Process
void calcTAT(Process myProcessIn);
// fucntion that calculates Total CPU time
void calcTCT(Process myProcessIn);
// funtion that calculates Wait Time
void calcWT(Process myProcessIn);
// function that calculates percentage of CPU utilization time
void calcCUT(Process myProcessIn);
// function that calculates the average Turn around time
void calcAvgTAT();
// function that calculates the average Wait time
void calcAvgWT();
// function that calculates the average CPU utilization time
void calcAvgCUT();
 
 
*/
//***********************************
// main
//***********************************
 
int main() {
 
ProcessContents *process;
ProcessContents Startup, Active, Expired, Finished, Io, Cpu;
 
int numTotalBursts= 0;
// check to see if the input is specified and correct
 
i = 0;
// Get input from the file and load startup queue
cout << " Begin startup queue initialization " << endl;
// get the max number of Processes
cin >> maxProcesses;
process = new ProcessContents;
// Check to make sure its not the end of the file
while(cin.eof() == 0 && maxProcesses != 0) {
// give it a pid first
process -> pid = i;
i++;
cout << "pid:" << process -> pid << endl;
// get Processes nice value
cin >> process -> nice;
cout << "nice:" << process -> nice << endl;
// get Processes arrival time
cin >> process -> arrivalTime;
cout << "atime:" << process -> arrivalTime << endl;
// get Processes number of cpu bursts
cin >> process -> numCPUBursts;
cout << "#cpu bursts:" << process -> numCPUBursts << endl;
// calculate the number of io bursts ( numer of cpu bursts - 1)
process -> numIOBursts = process -> numCPUBursts - 1;
cout << "#io bursts:" << process -> numIOBursts << endl;
// get the total bursts in the process
process -> totalBursts = process -> numIOBursts + process -> numCPUBursts;
cout << "#total bursts: " << process -> totalBursts << endl;
process -> burst = new int[process -> totalBursts]; 
 
// get the cpu bursts or io bursts
for (j = process -> totalBursts - 1; j >= 0; j--) {
cin >> process -> burst[j];
cout << "Burst: " << j << " is " << process-> burst[j] << " long." << endl;
 
} // end of read for bursts
 
Startup.insert(process);
 
} // end of read for an entire file
cout << " Done initilizing startup queue " << endl;
for(; !Startup.isBeginning(); Startup.prev())
 
	Startup.getData();
 
return 0;
}
 
//***********************************
// functions
//***********************************
 
/*
// function that prints Arrival Processes in the active queue
void printArrivalActive(Process myProcessIn) {
 
}
 
// function that prints when a Process enters the cpu
void printEnterCPU(Process myProcessIn, int time) {
 
}
 
// function that prints when a Process is preempted
void printPreempt(Process myProcessIn, Process myProcessOut, int time) {
 
}
 
//function that prints when a Process is finsihed with all cpu bursts
void printFinishCPU(Process myProcessOut, int time) {
 
}
 
// function that prints when a Process finishes a cpu burst and moves to the I/O queue
void printCPUToIO(Process myProcessOut, int time) {
 
}
 
// funcation that prints when a Process finishes its timeslice and moves to the expired queue
void printExpiredTimeslice(Process myProcessOut, int time) {
 
}
 
// function that prints when a Process finishes I/O burst and moves to the expired queue
void printIOToExpired(Process myProcessOut, int time) {
 
}
 
// function that prints when a Process finishes I/O burst and moves to active queue
void printIOToActive(Process myProcessOut, int time) {
 
}
 
// function that prints when the active and expired arrays are swapped
void printSwap(int time) {
 
}
 
// function that calculates Turn around time for a Process
void calcTAT(Process myProcessIn) [
 
}
 
// fucntion that calculates Total CPU time
void calcTCT(Process myProcessIn) {
 
}
 
// funtion that calculates Wait Time
void calcWT(Process myProcessIn) {
 
}
 
// function that calculates percentage of CPU utilization time
void calcCUT(Process myProcessIn) {
 
}
 
// function that calculates the average Turn around time
void calcAvgTAT() {
 
}
 
// function that calculates the average Wait time
void calcAvgWT() {
 
}
 
// function that calculates the average CPU utilization time
void calcAvgCUT() {
 
}
*/
//***********************************
// include files
//***********************************
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cctype>
#include <cstdlib>
#include <cmath>
using namespace std;
typedef unsigned char boolean;

//***********************************
// define directives
//***********************************
// Directive to store the minimum time slice
#define MIN_TIME_SLICE 10
// Directive to store the maximum time slice
#define MAX_TIME_SLICE 300
// Directive to store the lowest priority (*note* higher number = lower priority)
#define MIN_PRIORITY 140
// Directive to store the highest priority(*note* lower number = higher priority)
#define MAX_PRIORITY 100
// Directive to store the highest nice value(*note* lower number = nicer Process)
#define MAX_NICE = -20
// Directive to store the lowest nice value (*note* higher number = not so nice Process)
#define MIN_NICE = 19

//***********************************
// globals
//***********************************

// Clock for my scheduler
long myClock;
// Max amount of proccess in the file
int maxProcesses;
// Total turn around time for all Processes
long totalTAT;
// Total wait time for all Processes
long totalWT;
// Total CPU utiliation Time for all Processes
double totalCUT;
// The global count variables that gets used over and over again
int i, j, k;
// The global temp integer variable
int tempInt;

// class that defines what a Processes is
class ProcessContents{
	public:
	// constructors
	ProcessContents( );
	ProcessContents(ProcessContents*);
	// values in a process
	int pid;  //pid of Process
	int nice; // Processes nice value
	int arrivalTime;  // Processes arrival time
	int numCPUBursts;  // number of cpu bursts
	int numIOBursts;  // number of i/o bursts = #cpu bursts - 1
	int totalBursts;
	int endTime;  // Processes end time
	int priority;  // priority of Process
	int timeslice;  // Processes timesliceSTRUCT AS A FUNCTION PARAMETER DECLARATION
	int* burst;  // dynamic array of cpu bursts and io bursts for the Process
	
	void insert(ProcessContents*);  
	void setData(ProcessContents*);
	// setters
	ProcessContents* getPrev();
    ProcessContents* getNext();
    void setNext(ProcessContents*);    
	ProcessContents getData();
    int getDataEl();
	
	void reset();
    void prev();
    void next();
    void end();  
	
	//Boolean
    boolean isBeginning();
    boolean isEnd();
    boolean isEmpty();
	
	private:
	ProcessContents *m_next, *m_prev, *m_curr;
	
};



ProcessContents :: ProcessContents() {
  m_prev = NULL;
  m_next = NULL;
  m_curr = this;
  endTime = 0;
  priority = 69;
  timeslice = 143;
  burst = NULL;
}

ProcessContents :: ProcessContents(ProcessContents* previous) {
  m_prev = previous;
  cout << " PRINT PREVIOUS " << previous << endl;
  m_next = NULL;
  priority = 96;
  
}

void ProcessContents::insert(ProcessContents* pNode) {
  while (m_curr->getNext() != NULL)
    m_curr = m_curr->getNext();
 
  m_curr->setData(pNode);
  cout << "POINTERS: "<< m_curr<< " " << m_next << " " << m_prev << endl;
  m_curr->setNext(new ProcessContents(m_curr)); 
	cout << "POINTERS AFTER: "<< m_curr<< " " << m_next << " " << m_prev << endl;

 // creates the link between a newly created list and the current list
}

void ProcessContents::setData(ProcessContents* pNode) {
  int z;
  pid = pNode -> pid;
  nice = pNode -> nice;
  arrivalTime = pNode -> arrivalTime;
  numCPUBursts = pNode -> numCPUBursts;
  numIOBursts = pNode -> numIOBursts;
  totalBursts = pNode -> totalBursts;
  endTime = pNode -> endTime;
  priority = pNode -> priority;
  timeslice = pNode -> timeslice; 
  burst = new int[totalBursts]; 
  for (z = totalBursts - 1; z >= 0; z--) {
  burst[z] = pNode -> burst[z];
  }
  
}

ProcessContents ProcessContents::getData() {
  cout << "Pid: " << pid << endl;
  cout << "Arrival time: " << arrivalTime << endl;
  cout << "Priority: " << priority << endl;
  cout << "Total Burst: " << totalBursts << endl;

}

ProcessContents* ProcessContents::getPrev() {
  return m_prev;
}

ProcessContents* ProcessContents::getNext() {
  return m_next;
}

void ProcessContents::setNext(ProcessContents* link) {
  m_next = link;
}


void ProcessContents::reset() {
  m_curr = this;
}

void ProcessContents::next() {
  m_curr = m_curr->getNext();
}

void ProcessContents::prev() {
  m_curr = m_curr->getPrev();
}

boolean ProcessContents::isEnd() {
  return m_curr->getNext() == NULL ? 1 : 0;
}

boolean ProcessContents::isBeginning() {
  return m_curr == NULL ? 1 : 0; ;
}

boolean ProcessContents::isEmpty() {
  return m_curr->getNext() == m_curr->getPrev() ? 1 : 0;
}

/*
int Queue :: calculateDynPty(ProcessContents* node){
// have to adjust this part
  node -> priority = (node -> priority) + (-1)*((node -> Bonus) + (node -> priority));
  
  return (node -> priority);
}

double Queue :: calculateTimeSlice(ProcessContents *node){
  node -> priority = (int)ceil((-180.0/49.0)*(double)(calculateDynPty(node))+(26900.0/49.0));
  return (node -> priority);
}

*/

//***********************************
// function definitions
//***********************************

// Function that gets all the input from unix file redirection and places them into the startup queue

/*
// *****************MOST PRINT STATEMENTS*******************************
// function that prints Arrival Processes in the active queue
void printArrivalActive(Process myProcessIn);
// function that prints when a Process enters the cpu
void printEnterCPU(Process myProcessIn, int time);
// function that prints when a Process is preempted
void printPreempt(Process myProcessIn, Process myProcessOut, int time);
//function that prints when a Process is finsihed with all cpu bursts
void printFinishCPU(Process myProcessOut, int time);
// function that prints when a Process finishes a cpu burst and moves to the I/O queue
void printCPUToIO(Process myProcessOut, int time);
// funcation that prints when a Process finishes its timeslice and moves to the expired queue
void printExpiredTimeslice(Process myProcessOut, int time);
// function that prints when a Process finishes I/O burst and moves to the expired queue
void printIOToExpired(Process myProcessOut, int time);
// function that prints when a Process finishes I/O burst and moves to active queue
void printIOToActive(Process myProcessOut, int time);
// function that prints when the active and expired arrays are swapped
void printSwap(int time);

// *****************MOST CALC STATEMENTS********************************
// function that calculates Turn around time for a Process
void calcTAT(Process myProcessIn);
// fucntion that calculates Total CPU time
void calcTCT(Process myProcessIn);
// funtion that calculates Wait Time
void calcWT(Process myProcessIn);
// function that calculates percentage of CPU utilization time
void calcCUT(Process myProcessIn);
// function that calculates the average Turn around time
void calcAvgTAT();
// function that calculates the average Wait time
void calcAvgWT();
// function that calculates the average CPU utilization time
void calcAvgCUT();


*/
//***********************************
// main
//***********************************

int main() {

ProcessContents *process;
ProcessContents Startup, Active, Expired, Finished, Io, Cpu;

int numTotalBursts= 0;
// check to see if the input is specified and correct

i = 0;
// Get input from the file and load startup queue
cout << " Begin startup queue initialization " << endl;
// get the max number of Processes
cin >> maxProcesses;
process = new ProcessContents;
// Check to make sure its not the end of the file
while(cin.eof() == 0 && maxProcesses != 0) {
// give it a pid first
process -> pid = i;
i++;
cout << "pid:" << process -> pid << endl;
// get Processes nice value
cin >> process -> nice;
cout << "nice:" << process -> nice << endl;
// get Processes arrival time
cin >> process -> arrivalTime;
cout << "atime:" << process -> arrivalTime << endl;
// get Processes number of cpu bursts
cin >> process -> numCPUBursts;
cout << "#cpu bursts:" << process -> numCPUBursts << endl;
// calculate the number of io bursts ( numer of cpu bursts - 1)
process -> numIOBursts = process -> numCPUBursts - 1;
cout << "#io bursts:" << process -> numIOBursts << endl;
// get the total bursts in the process
process -> totalBursts = process -> numIOBursts + process -> numCPUBursts;
cout << "#total bursts: " << process -> totalBursts << endl;
process -> burst = new int[process -> totalBursts]; 

// get the cpu bursts or io bursts
for (j = process -> totalBursts - 1; j >= 0; j--) {
cin >> process -> burst[j];
cout << "Burst: " << j << " is " << process-> burst[j] << " long." << endl;

} // end of read for bursts

Startup.insert(process);

} // end of read for an entire file
cout << " Done initilizing startup queue " << endl;
for(; !Startup.isBeginning(); Startup.prev())
   
	Startup.getData();

return 0;
}

//***********************************
// functions
//***********************************

/*
// function that prints Arrival Processes in the active queue
void printArrivalActive(Process myProcessIn) {

}

// function that prints when a Process enters the cpu
void printEnterCPU(Process myProcessIn, int time) {

}

// function that prints when a Process is preempted
void printPreempt(Process myProcessIn, Process myProcessOut, int time) {

}

//function that prints when a Process is finsihed with all cpu bursts
void printFinishCPU(Process myProcessOut, int time) {

}

// function that prints when a Process finishes a cpu burst and moves to the I/O queue
void printCPUToIO(Process myProcessOut, int time) {

}

// funcation that prints when a Process finishes its timeslice and moves to the expired queue
void printExpiredTimeslice(Process myProcessOut, int time) {

}

// function that prints when a Process finishes I/O burst and moves to the expired queue
void printIOToExpired(Process myProcessOut, int time) {

}

// function that prints when a Process finishes I/O burst and moves to active queue
void printIOToActive(Process myProcessOut, int time) {

}

// function that prints when the active and expired arrays are swapped
void printSwap(int time) {

}

// function that calculates Turn around time for a Process
void calcTAT(Process myProcessIn) [

}

// fucntion that calculates Total CPU time
void calcTCT(Process myProcessIn) {

}

// funtion that calculates Wait Time
void calcWT(Process myProcessIn) {

}

// function that calculates percentage of CPU utilization time
void calcCUT(Process myProcessIn) {

}

// function that calculates the average Turn around time
void calcAvgTAT() {

}

// function that calculates the average Wait time
void calcAvgWT() {

}

// function that calculates the average CPU utilization time
void calcAvgCUT() {

}
*/

my input file looks like:

6
0 16 3 100 100 100 100 100
-4 100 3 300 30 300 10 200
-20 200 2 12 30 300
0 25 1 300
15 50 3 340 290 582 102 10
-15 0 4 20 400 10 200 100 45 6

and my output right now currently shows the address of pointers after certain executions and is a little messy since I have been working on debugging it for awhile.

Begin startup queue initialization
pid:0
nice:0
atime:16
#cpu bursts:3
#io bursts:2
#total bursts: 5
Burst: 4 is 100 long.
Burst: 3 is 100 long.
Burst: 2 is 100 long.
Burst: 1 is 100 long.
Burst: 0 is 100 long.
POINTERS: 0xbfc5447c 0 0
PRINT PREVIOUS 0xbfc5447c
POINTERS AFTER: 0xbfc5447c 0x9360070 0
pid:1
nice:-4
atime:100
#cpu bursts:3
#io bursts:2
#total bursts: 5
Burst: 4 is 300 long.
Burst: 3 is 30 long.
Burst: 2 is 300 long.
Burst: 1 is 10 long.
Burst: 0 is 200 long.
POINTERS: 0x9360070 0x9360070 0
PRINT PREVIOUS 0x9360070
POINTERS AFTER: 0x9360070 0x9360070 0
pid:2
nice:-20
atime:200
#cpu bursts:2
#io bursts:1
#total bursts: 3
Burst: 2 is 12 long.
Burst: 1 is 30 long.
Burst: 0 is 300 long.
POINTERS: 0x93600d8 0x9360070 0
PRINT PREVIOUS 0x93600d8
POINTERS AFTER: 0x93600d8 0x9360070 0
pid:3
nice:0
atime:25
#cpu bursts:1
#io bursts:0
#total bursts: 1
Burst: 0 is 300 long.
POINTERS: 0x9360130 0x9360070 0
PRINT PREVIOUS 0x9360130
POINTERS AFTER: 0x9360130 0x9360070 0
pid:4
nice:15
atime:50
#cpu bursts:3
#io bursts:2
#total bursts: 5
Burst: 4 is 340 long.
Burst: 3 is 290 long.
Burst: 2 is 582 long.
Burst: 1 is 102 long.
Burst: 0 is 10 long.
POINTERS: 0x9360188 0x9360070 0
PRINT PREVIOUS 0x9360188
POINTERS AFTER: 0x9360188 0x9360070 0
pid:5
nice:-15
atime:0
#cpu bursts:4
#io bursts:3
#total bursts: 7
Burst: 6 is 20 long.
Burst: 5 is 400 long.
Burst: 4 is 10 long.
Burst: 3 is 200 long.
Burst: 2 is 100 long.
Burst: 1 is 45 long.
Burst: 0 is 6 long.
POINTERS: 0x93601f0 0x9360070 0
PRINT PREVIOUS 0x93601f0
POINTERS AFTER: 0x93601f0 0x9360070 0
Done initilizing startup queue
Pid: 0
Arrival time: 16
Priority: 69
Total Burst: 5
Pid: 0
Arrival time: 16
Priority: 69
Total Burst: 5
Pid: 0
Arrival time: 16
Priority: 69
Total Burst: 5
Pid: 0
Arrival time: 16
Priority: 69
Total Burst: 5
Pid: 0
Arrival time: 16
Priority: 69
Total Burst: 5
Pid: 0
Arrival time: 16
Priority: 69
Total Burst: 5

Similar Threads

Circular linked list in C
Removing an item from head of linked list in C
Double-linked list in contiguous memory. in C
radix sort using queue and linked list in C++
qustion about the double link list in C

lvphoenix

Reputation Points: 29

Solved Threads: 0

Newbie Poster

Offline

1 posts
since Oct 2007

Permalink

Oct 12th, 2007

Re: Issues with double linked list

A big construction. You may be good at linked list. plz show me some of document i can improve and develop my skill at this. thank you first.

vincent551987vn

Reputation Points: 10

Solved Threads: 1

Newbie Poster

Offline

14 posts
since Oct 2007

Permalink

Oct 12th, 2007

Re: Issues with double linked list

>Any help would be greatly appreciated I have been banging
>my head on the desk for the last 7 hours working on it.
Remove the unnecessary code and work directly with the linked list. You're definitely not handling the links correctly, so I'm going to assume that you need a refresher on linked lists in general and send you here.

Narue

Administrator

Reputation Points: 6442

Solved Threads: 1393

Bad Cop

Offline

11,807 posts
since Sep 2004

This thread is more than three months old

No one has posted to this discussion for at least three months. Please let old threads die and do not reply to them unless you feel you have something new and valuable to contribute that absolutely must be added to make the discussion complete. Otherwise, please start a new thread in this forum instead.

Previous Thread in C++ Forum Timeline: Newbie

Next Thread in C++ Forum Timeline: ASCII codes

DaniWeb Message

Cancel Changes

User Name
Password