Linked List queue

Below isSource code:

 

-------------------------------------------------------------

 

# Include <iostream>

Using namespace STD;

 

# Define OK 1

# Define error 0

 

Typedef int status;

Typedef struct qnode

{

Int data;

Struct qnode * next;

} Qnode, * qnodeptr;

 

 

//////////////////////////////////////// /////////

// Linkqueue class declaration

//

Class linkqueue

{

PRIVATE:

Qnodeptr front;

Qnodeptr rear;

Public:

Linkqueue ();

~ Linkqueue ();

Status clearqueue ();

Status queueempty ();

Int queuelength ();

Status gethead (Int & E );

Status enqueue (int e );

Status dequeue (Int & E );

Status queuetraverse (status visit (qnode & E ));

Status putqueue ();

};

 

 

 

//////////////////////////////////////// /////////

// Implementation of the linkqueue class

//

Linkqueue: linkqueue ()

{

Front = static_cast <qnodeptr> (New qnode );

Front-> next = NULL;

Rear = front;

}

 

Linkqueue ::~ Linkqueue ()

{

Qnodeptr temp = front;

While (front! = Rear)

{

Front = front-> next;

Delete temp;

Temp = front;

}

Delete temp;

Front = NULL;

Rear = NULL;

}

 

 

 

Status linkqueue: clearqueue ()

{

Qnodeptr plink = front-> next, temp = front-> next;

While (plink! = Rear)

{

Plink = plink-> next;

Delete temp;

Temp = plink;

}

Rear = front;

Delete temp;

Return OK;

}

 

 

Status linkqueue: queueempty ()

{

Return front = rear;

}

 

 

Int linkqueue: queuelength ()

{

Int length = 0;

Qnodeptr plink = front-> next;

While (plink! = Rear-> next)

{

Plink = plink-> next;

Length ++;

}

Return length;

}

 

 

Status linkqueue: gethead (Int & E)

{

If (! Queueempty ())

{

E = front-> next-> data;

Return OK;

}

Else

{

Return Error;

}

}

 

 

 

Status linkqueue: enqueue (int e)

{

Qnodeptr temp;

Temp = static_cast <qnodeptr> (New qnode );

If (! Temp)

{

Exit (1 );

}

Temp-> DATA = E;

Temp-> next = NULL;

Rear-> next = temp;

Rear = temp;

Return OK;

}

 

 

Status linkqueue: dequeue (Int & E)

{

If (front = rear)

{

Return Error;

}

Qnodeptr temp = front-> next;

E = temp-> data;

Front-> next = temp-> next;

If (temp = rear)

{

Rear = front;

}

Delete temp;

Return OK;

}

 

Status linkqueue: queuetraverse (status visit (qnode & E ))

{

Qnodeptr plink = front-> next;

While (plink! = Rear-> next)

{

 

If (! Visit (* plink ))

{

Return Error;

}

Plink = plink-> next;

}

Return OK;

}

 

Status linkqueue: putqueue ()

{

Qnodeptr plink = front-> next;

Cout <"queue --> ";

While (plink! = Rear-> next)

{

Cout <plink-> data <"";

Plink = plink-> next;

}

Cout <Endl;

Return OK;

}

 

 

//////////////////////////////////////// /////////

// Other auxiliary functions

//

Status add (qnode & E)

{

E. Data ++;

Return OK;

}

 

Status sub (qnode & E)

{

E. Data --;

Return OK;

}

 

 

//////////////////////////////////////// /////////

// Main Function

//

Int main ()

{

Int I, E;

Linkqueue queue;

Queue. putqueue ();

For (I = 0; I <5; I ++)

{

Cout <"input the" <I + 1 <"ELEM :";

Cin> E;

Queue. enqueue (E );

Queue. putqueue ();

}

Queue. queuetraverse (ADD );

Queue. putqueue ();

Queue. queuetraverse (sub );

Queue. putqueue ();

While (! Queue. queueempty ())

{

Queue. dequeue (E );

Cout <"the element that have been dequeued is:" <e <Endl;

Queue. putqueue ();

}

For (I = 0; I <5; I ++)

{

Cout <"input the" <I + 1 <"ELEM :";

Cin> E;

Queue. enqueue (E );

Queue. putqueue ();

}

Queue. clearqueue ();

Queue. putqueue ();

Return OK;

}