数据结构：链队列

professor's code:

#include
#include

typedef struct LinkNode{
    int data;
    LinkNode* next;
}*LinkNodePtr;

typedef struct LinkQueue{
    LinkNodePtr front;
    LinkNodePtr rear;
}*LinkQueuePtr;

LinkQueuePtr initQueue(){
    LinkQueuePtr resultPtr = (LinkQueuePtr)malloc(sizeof(struct LinkQueue));
    //The header, the data is not useful.
    LinkNodePtr headerPtr = (LinkNodePtr)malloc(sizeof(struct LinkNodePtr));
    headerPtr->next = NULL;
    
    resultPtr->front = headerPtr;
    resultPtr->rear = headerPtr;
    return resultPtr;
}//Of initQueue

void outputLinkQueue(LinkQueuePtr paraQueuePtr){
    LinkNodePtr tempPtr = paraQueuePtr->front->next;
    while (tempPtr != NULL) {
        printf("%d ", tempPtr->data);
        tempPtr = tempPtr->next;
    }//Of while
    printf("rn");
}//Of outputLinkQueue

void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) {
    //Step 1. Create a new node
    LinkNodePtr tempNodePtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
    tempNodePtr->data = paraElement;
    tempNodePtr->next = NULL;
    
    //Step 2. Link to the existing rear
    paraQueuePtr->rear->next = tempNodePtr;
    
    //Step 3. It is the new rear
    paraQueuePtr->rear = tempNodePtr;
}//Of enqueue

int dequeue(LinkQueuePtr paraQueuePtr) {
    int resultValue;
    LinkNodePtr tempNodePtr;

    //Step 1. Is the queue empty?
    if (paraQueuePtr->front == paraQueuePtr->rear) {
        printf("The queue is empty.rn");
        return -1;
    }//Of if

    //Step 2. Change the queue.
    tempNodePtr = paraQueuePtr->front->next;
    resultValue = tempNodePtr->data;
    paraQueuePtr->front->next = paraQueuePtr->front->next->next;

    if (paraQueuePtr->rear == tempNodePtr) {
        paraQueuePtr->rear = paraQueuePtr->front;
    }//Of if

    //Step 3. Free space.
    // free(tempNodePtr);
    tempNodePtr = NULL;

    //Step 4. Return.
    return resultValue;
}//Of enqueue
    

void testLinkQueue(){
    LinkQueuePtr tempQueuePtr;
    tempQueuePtr = initQueue();
    enqueue(tempQueuePtr, 10);
    enqueue(tempQueuePtr, 30);
    enqueue(tempQueuePtr, 50);

    outputLinkQueue(tempQueuePtr);

    printf("dequeue gets %drn", dequeue(tempQueuePtr));
    printf("dequeue gets %drn", dequeue(tempQueuePtr));
    printf("dequeue gets %drn", dequeue(tempQueuePtr));
    printf("dequeue gets %drn", dequeue(tempQueuePtr));

    enqueue(tempQueuePtr, 8);
    outputLinkQueue(tempQueuePtr);
}//Of testLinkQueue
 

int main(){
    testLinkQueue();
    return 1;
}//Of main
 

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

my code:

#include
#include
typedef struct node
{
    int data;
    node* next;
}* nodeptr;

typedef struct queue
{
    nodeptr front;
    nodeptr rear;
}* queueptr;

queueptr init()
{
    queueptr temptr = (queueptr)malloc(sizeof(queue));//创建队列
    nodeptr headptr = (nodeptr)malloc(sizeof(node));//创建链表
    headptr->next = NULL;
    temptr->front = headptr;
    temptr->rear = headptr;
    return temptr;
}

void enqueue(queueptr temqueueptr,int element)
{
    //创建一个新的结点
    nodeptr newnode = (nodeptr)malloc(sizeof(node));
    newnode->data = element;
    newnode->next = NULL;
    //链接
    temqueueptr->rear->next = newnode;
    temqueueptr->rear = newnode;
}

void print(queueptr temqueueptr)
{
    nodeptr temptr = temqueueptr->front->next;
    while (temptr != NULL)
    {
        printf("%dn", temptr->data);
        temptr = temptr->next;
    }
    printf("n");
}

int dequeue(queueptr temqueueptr)
{
    int resultValue;
    nodeptr tempNodePtr;
    if (temqueueptr->front == temqueueptr->rear)
    {
        printf("The queue is empty.n");
        return -1;
    }

    tempNodePtr = temqueueptr->front->next;
    resultValue = tempNodePtr->data;
    temqueueptr->front->next = temqueueptr->front->next->next;

    if (temqueueptr->rear == tempNodePtr) 
    {
        temqueueptr->rear = temqueueptr->front;
    }
    tempNodePtr = NULL;
    return resultValue;
}

int main()
{
    queueptr temptr = init();
    enqueue(temptr, 10);
    enqueue(temptr, 30);
    enqueue(temptr, 50);
    print(temptr);
    for (int i = 0; i < 4; i++)
    {
        dequeue(temptr);
        print(temptr);
    }
    return 0;
}