Atari Computer

Beispiel: Queue

Die folgenden Beispiele zeigen eine Queue.

Sprache	C	Pascal	Modula
Beispiel	queue.c	queue.pas	queue.mod

queue.c

/* Da der Datentyp der Queue erst bei einer konkreten Anwendung  */
/* feststeht, ist die Queue nur als Beispiel und nicht als Modul */
/* programmiert. Mit mehr Aufwand k�nnte man auch Zeiger auf die */
/* Daten (in Pascal �ber variante Records als long_integer) ab-  */
/* speichern und damit eine universelle Queue implementieren.    */

#include 
#include 
#include 

typedef long QueueDataType;
typedef struct queue_element {
   QueueDataType Daten;
   struct queue_element *Next;
} QueueElement, *QueueKnoten;
typedef struct {
   QueueKnoten First, Last;
} Queue;

void QueueCreate(Queue *MyQueue)
{
   MyQueue->First = NULL;
   MyQueue->Last = NULL;
}

int QueueIsEmpty(Queue *MyQueue)
{
   return(MyQueue->First == NULL);
}

void QueueAdd(Queue *MyQueue, QueueDataType Daten)
{  QueueKnoten NewElement;

   NewElement = malloc(sizeof(QueueElement));
   NewElement->Daten = Daten;
   NewElement->Next = NULL;
   if (QueueIsEmpty(MyQueue))
   {
      MyQueue->First = NewElement;
      MyQueue->Last = NewElement;
   }
   else
   {
      (MyQueue->Last)->Next = NewElement;
      MyQueue->Last = NewElement;
   }
}

void QueueGet(Queue *MyQueue, QueueDataType *Daten)
{
   if (!QueueIsEmpty(MyQueue))
      *Daten = MyQueue->First->Daten;
}

void QueueRemove(Queue *MyQueue)
{  QueueKnoten OldElement;

   if (!QueueIsEmpty(MyQueue))
   {
      OldElement = MyQueue->First;
      if (MyQueue->First == MyQueue->Last)
      {
         MyQueue->First = NULL;
         MyQueue->Last = NULL;
      }
      else
         MyQueue->First = MyQueue->First->Next;
      free(OldElement);
   }
}

queue.pas

(* Da der Datentyp der Queue erst bei einer konkreten Anwendung  *)
(* feststeht, ist die Queue nur als Beispiel und nicht als Modul *)
(* programmiert. Mit mehr Aufwand k�nnte man auch Zeiger auf die *)
(* Daten (in Pascal �ber variante Records als long_integer) ab-  *)
(* speichern und damit eine universelle Queue implementieren.    *)

type
   QueueDataType = long_integer;
   QueueKnoten = ^QueueElement;
   QueueElement = record
      Daten : QueueDataType;
      Next : QueueKnoten;
   end;
   Queue = record
      First, Last : QueueKnoten;
   end;

procedure QueueCreate(var MyQueue:Queue);
begin
   MyQueue.First := nil;
   MyQueue.Last := nil;
end;

function QueueIsEmpty(MyQueue:Queue):boolean;
begin
   QueueIsEmpty := MyQueue.First=nil;
end;

procedure QueueAdd(var MyQueue:Queue; Daten:QueueDataType);
var
   NewElement : QueueKnoten;
begin
   new(NewElement);
   NewElement^.Daten := Daten;
   NewElement^.Next := nil;
   if QueueIsEmpty(MyQueue) then
   begin
      MyQueue.First := NewElement;
      MyQueue.Last := NewElement;
   end
   else
   begin
      MyQueue.Last^.Next := NewElement;
      MyQueue.Last := NewElement;
   end;
end;

procedure QueueGet(MyQueue:Queue; var Daten:QueueDataType);
begin
   if not QueueIsEmpty(MyQueue) then
      Daten := MyQueue.First^.Daten;
end;

procedure QueueRemove(var MyQueue:Queue);
var
   OldElement : QueueKnoten;
begin
   if not QueueIsEmpty(MyQueue) then
   begin
      OldElement := MyQueue.First;
      if MyQueue.First = MyQueue.Last then
      begin
         MyQueue.First := nil;
         MyQueue.Last := nil;
      end
      else
         MyQueue.First := MyQueue.First^.Next;
      dispose(OldElement);
   end;
end;

queue.mod

MODULE Queue;

(* Da der Datentyp der Queue erst bei einer konkreten Anwendung  *)
(* feststeht, ist die Queue nur als Beispiel und nicht als Modul *)
(* programmiert. Mit mehr Aufwand k�nnte man auch Zeiger auf die *)
(* Daten (in Pascal �ber variante Records als long_integer) ab-  *)
(* speichern und damit eine universelle Queue implementieren.    *)

FROM Heap IMPORT Allocate, Deallocate;
FROM SYSTEM IMPORT TSIZE;

TYPE
   QueueDataType = LONGINT;
   QueueKnoten = POINTER TO QueueElement;
   QueueElement = RECORD
      Daten : QueueDataType;
      Next : QueueKnoten;
   END;
   Queue = RECORD
      First, Last : QueueKnoten;
   END;

PROCEDURE QueueCreate(VAR MyQueue:Queue);
BEGIN
   MyQueue.First := NIL;
   MyQueue.Last := NIL;
END QueueCreate;

PROCEDURE QueueIsEmpty(MyQueue:Queue) : BOOLEAN;
BEGIN
   RETURN MyQueue.First=NIL;
END QueueIsEmpty;

PROCEDURE QueueAdd(VAR MyQueue:Queue; Daten:QueueDataType);
VAR
   NewElement:QueueKnoten;
BEGIN
   Allocate(NewElement, TSIZE(QueueElement));
   NewElement^.Daten := Daten;
   NewElement^.Next := NIL;
   IF QueueIsEmpty(MyQueue) THEN
      MyQueue.First := NewElement;
      MyQueue.Last := NewElement;
   ELSE
      MyQueue.Last^.Next := NewElement;
      MyQueue.Last := NewElement;
   END;
END QueueAdd;

PROCEDURE QueueGet(MyQueue:Queue; VAR Daten:QueueDataType);
BEGIN
   IF NOT QueueIsEmpty(MyQueue) THEN
      Daten := MyQueue.First^.Daten;
   END;
END QueueGet;

PROCEDURE QueueRemove(VAR MyQueue:Queue);
VAR
   OldElement : QueueKnoten;
BEGIN
   IF NOT QueueIsEmpty(MyQueue) THEN
      OldElement := MyQueue.First;
      IF MyQueue.First = MyQueue.Last THEN
         MyQueue.First := NIL;
         MyQueue.Last := NIL;
      ELSE
         MyQueue.First := MyQueue.First^.Next;
      END;
      Deallocate(OldElement, TSIZE(QueueElement));
   END;
END QueueRemove;

English version not yet available.