数据结构学习笔记6（队列）

1链队列的初始化，建立，插入，查找，删除

转载自http://www.cnblogs.com/newwy/archive/2010/10/10/1847463.html。
本程序的队列实现思想：队列是先进先出的。也就是说看做从后面进从前面出。我本以为用链表实现时做一个双向链表，但是如本文所示，可以做两个链表指针分别指向对头和对尾用作插入数据、删除。至于计数什么的就很简单了

代码

 


//链队列的初始化，建立，插入，查找，删除。//
//Author:Wang Yong                            //    
//Date:    2010.8.19                            //




#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;

//

//定义队列结点类型

typedef struct Qnode
{
    ElemType data;
    struct Qnode *next;
} Qnode;

///定义队列结点的头指针，为指针 

typedef struct
{
    Qnode *front;
    Qnode *rear;
}LQueue,*LinkQueue; 

//

//队列初始化

LinkQueue LinkQueueInit()
{
    LinkQueue Q;
    Qnode *P;
    Q = (LinkQueue)malloc(sizeof(LQueue));//申请头，尾指针结点 
    P = (Qnode *)malloc(sizeof(Qnode));//申请头结点 
    P->next = NULL;
    Q->front = Q->rear = P;
    return Q; 
}

/

//入队

void LinkQueueEnter(LinkQueue Q,ElemType x)
{
    Qnode *p;
    
    p = (Qnode *)malloc(sizeof(Qnode));//申请新结点 
    p->data = x;
    p->next = NULL;

    Q->rear->next = p;
    
    Q->rear = p;

} 

/

//出队

ElemType LinkQueueOut(LinkQueue Q)
{
    ElemType x;
    Qnode *p;
    if(Q->front != Q->rear)
    {
        p = Q->front->next;;
        x = p->data;
        Q->front->next = p->next;//移动头指针 
        free(p);
        if(Q->front->next == NULL)//最后一个元素出队后，队空，修改队尾指针 
            Q->rear = Q->front;
    }
    else 
        return  0;
    return x;
} 
int main()
{
    LinkQueue lqueue;
    lqueue = LinkQueueInit();
    ElemType x;
    printf("请输入入队列的元素：");
    while(scanf("%d",&x) != EOF)
    {
        LinkQueueEnter(lqueue,x);
    }
    Qnode *p;
    
    for(p = lqueue->front->next; p != lqueue->rear->next; p = p->next )
        printf("%d ",p->data);
    printf("出队列的结果为：");
    while(lqueue->front!= lqueue->rear)
    {
        
        printf("%d ",LinkQueueOut(lqueue));
    }
    
    return 0;
}

2队列的数组实现 

转自 http://blog.youkuaiyun.com/feixiaoxing/article/details/6847885

//设计队列数据结构
typedef struct _QUEUE_NODE  
{  
    int* pData;  
    int length;  
    int head ;  
    int tail;  
    int count;  
}QUEUE_NODE;  
//申请队列内存
QUEUE_NODE* alloca_queue(int number)  
{  
    QUEUE_NODE* pQueueNode;  
    if( 0 == number)  
        return NULL;  
  
    pQueueNode = (QUEUE_NODE*)malloc(sizeof(QUEUE_NODE));  
    assert(NULL != pQueueNode);  
    memset(pQueueNode, 0, sizeof(QUEUE_NODE));  
  
    pQueueNode->pData = (int*)malloc(sizeof(int) * number);  
    if(NULL == pQueueNode->pData){  
        free(pQueueNode);  
        return NULL;  
    }  
  
    pQueueNode->length = number;  
    return pQueueNode;  
}  
//释放队列内存
STATUS delete_queue(const QUEUE_NODE* pQueueNode)  
{  
    if(NULL == pQueueNode)   
        return FALSE;  
      
    assert(NULL != pQueueNode->pData);  
      
    free(pQueueNode->pData);  
    free((void*)pQueueNode);  
    return TRUE;  
} 
//把数据压入队列
STATUS insert_queue(QUEUE_NODE* pQueueNode, int value)  
{  
    if(NULL == pQueueNode)  
        return FALSE;  
  
    if(pQueueNode->length == pQueueNode->count)  
        return FALSE;  
  
    pQueueNode->pData[pQueueNode->tail] = value;  
    pQueueNode->tail = (pQueueNode->tail + 1) % pQueueNode->length;    
    pQueueNode->count ++;  
    return TRUE;  
}
//把数据弹出队列
STATUS get_queue_data(QUEUE_NODE* pQueueNode, int* value)  
{  
    if(NULL == pQueueNode || NULL == value)  
        return FALSE;  
  
    if(0 == pQueueNode->count)  
        return FALSE;  
  
    *value = pQueueNode->pData[pQueueNode->head];  
    pQueueNode-> pData[pQueueNode->head] = 0;   
    pQueueNode-> count --;  
    pQueueNode->head = (pQueueNode->head + 1) % pQueueNode->length;  
    return TRUE;  
}  
//统计当前队列中有多少数据
int  get_total_number(const QUEUE_NODE* pQueueNode)  
{  
    if(NULL == pQueueNode)  
        return 0;  
  
    return pQueueNode->count;  
}  
//查看队列中初始化的时候总长度是多少
int  get_total_number(const QUEUE_NODE* pQueueNode)  
{  
    if(NULL == pQueueNode)  
        return 0;  
  
    return pQueueNode->length;  
}