数据结构review——队列

顺序队列

#include"queue.h"
#include<iostream>
#include"queue.cpp"

typedef struct Person{

    char name[64];
    int  age;

}person;


int main(int argc,char *argv[]){


    //创建队列
    queue *q = Init_SeqQueue();

    //创建数据
    
    person p1 = {"aaaa",10};
    person p2 = {"bbbb",20};
    person p3 = {"cccc",30};
    person p4 = {"dddd",40};


    Push_SeqQueue(q,&p1);
    Push_SeqQueue(q,&p2);
    Push_SeqQueue(q,&p3);
    
    Push_SeqQueue(q,&p4);

    printf("queue size : %d\n",
            Long_size_SeqQueue(q));

    person * pp = (person* )Back_SeqQueue(q);


     printf("Name: %s, age: %d  \n ", pp->name, pp->age);

    //输出
    while(Long_size_SeqQueue(q)>0){

        //取出隊头元素
         person *human = (person*)Front_SeqQueue(q);

        printf("Name: %s, age: %d  \n ", human->name, human->age);
        Pop_SeqQuenue(q);
    
    }
    FreeSpace_SeqQueue(q);

    system("pause");
    return 0;
}

#include"queue.h"
#include<iostream>


//队列为先进先出
//因为该程序以数组的左侧为队头
//初始化
queue *Init_SeqQueue(){

    queue* q = new queue;

    for (int i = 0; i< q->size; i++)
        q->data[i] = NULL; 
    q->size = 0;

    return q;
}


//入队
void Push_SeqQueue(queue * q, void *data){

    if(q==NULL){
        return ;
    }
    if(data ==NULL){
        return ;
    }
    q->data[q->size] = data;
    q->size ++;
}


//出队
void Pop_SeqQuenue(queue *q){

    //需要移动元素
    if(q == NULL){
        return;
    }
       for(int i = 0; i < q->size; i++)
        q->data[i] = q->data[i+1];
        q->size--;

}

//返回队头元素
void * Front_SeqQueue(queue *q){

    if(q->data==NULL){
        return NULL;
    }
    if(q->size==0){
        return NULL;
    }
    return q->data[0];
}

//判断队是否为空
void IsEmpty_SeqQueue(queue *q){

    if(q->data==NULL){
        return ;
    }
    if(q->size==0){
        return ;
    }
}

//返回队尾位置
void *Back_SeqQueue(queue *q){

    return q->data[q->size-1];

}

//返回队伍长度
int Long_size_SeqQueue(queue*q){
    return q->size;
}

//清空队列
void Clear_SeqQueue(queue*q){
    IsEmpty_SeqQueue(q);
    for(int i = 0; i< q->size;q++){
        q->data[q->size-1] = NULL; 
    }
    q->size = 0 ;
}

//销毁
void FreeSpace_SeqQueue(queue*q){
   free(q);
}

#ifndef QUEUE_H
#define QUEUE_H
#define maxsize 1024

//队列只能一段插入，另一端删除
typedef struct queue
{
    void*data[maxsize];//
    int size;
}queue;

//初始化
queue *Init_SeqQueue();

//入队
void Push_SeqQueue(queue * q, void *data);

//出队
void Pop_SeqQuenue(queue *q);

//返回队头元素
void * Front_SeqQueue(queue *q);

//判断队是否为空
void IsEmpty_SeqQueue(queue *q);

//返回队尾位置
void *Back_SeqQueue(queue *q);

//返回队伍长度
int Long_size_SeqQueue(queue*q);

//清空队列
void Clear_SeqQueue(queue*q);


//销毁
void FreeSpace_SeqQueue(queue*q);

#endif 

链队

#include"LinkQueue.h"
#include"LinkQueue.cpp"

typedef struct Person{

    char name[64];
    int age;

}person;


int main(){

    LinkQueue * queue = InitQueue();

    push_queue(queue,1);
    push_queue(queue,2);
    push_queue(queue,3);
    pop_queue(queue);

    int  head= front_element(queue);

    printf("linkqueue top element:%d\n", head);

    int size = size_linkqueue(queue);
    printf("linkqueue size: %d\n",size);

    printf("rear Element : %d",Back_SeqQueue(queue));

    

    clear_linkqueue(queue);
    DestoryQueue(queue);


    return 0;
}

#ifndef LINKQUEUE_H
#define LINKQUEUE_H


#include<iostream>
//#pragma once

// #ifdef __cplusplus
// extern "C"{ // C语言中的函数名字是不一样的
// #endif
//鏈式存儲實際上還是用鏈表來模仿隊列

//鏈表節點的數據類型
 
struct QNode    //定义队列结点的数据结构
{
	QNode *next; //指针域,指向下一个结点
	double data;    //数据域，存储队列信息
};
 
struct LinkQueue    //定义队列的数据结构
{
	QNode *front;      //队首指针,指向QNode类型的指针
	QNode *rear;       //队尾指针
    int size;
};
 

//初始化队列
LinkQueue * InitQueue();


//判断队列是否为空

int IsEmpty(LinkQueue *Q) ;

//入队
void push_queue(LinkQueue *queue, int data);

//返回队顶元素
int front_element(LinkQueue* queue);

//出队
void pop_queue(LinkQueue* queue);

//返回队尾元素
int Back_SeqQueue(LinkQueue *queue);

//返回队伍长度
int size_linkqueue(LinkQueue *queue);

//清空队列
void clear_linkqueue(LinkQueue*queue);

void DestoryQueue(LinkQueue*queue);

// #ifdef __cplusplus
// extern "C"{
// #endif

#endif

#include"LinkQueue.h"

//初始化队列
LinkQueue * InitQueue(){

    LinkQueue *Q = new LinkQueue;
    QNode *q;
	q = new QNode;    //申请一个结点的空间
	q->next = NULL;   //当作头结点
	//队首与队尾指针都指向这个结点，指针域为NULL
	Q->front = q;
	Q->rear = q;
    Q->size = 0;


    return Q;

}
//入队
void push_queue(LinkQueue *queue, int data){

    QNode *p;    //新创建一个结点
	p = new QNode;
	p->next = NULL;
	p->data = data;  //输入数据信息
	//将新结点插入队列尾部
	queue->rear->next = p;
	queue->rear = p;       //设置新的尾结点

    queue->size ++;

}

int IsEmpty(LinkQueue *Q)    //判断队列是否为空
{
	if (Q->rear == Q->front)
		return 0;
	else
		return 1;
}
 
//返回队顶元素
int front_element(LinkQueue* queue ){

    //当然这些程序在操作的时候都需要是否为NULL 或者越界
    return queue->front->next->data;
}

//出队
void pop_queue(LinkQueue* queue){

    if(0 == IsEmpty(queue)){

        exit(EXIT_FAILURE);
    }
    QNode *p;
	p = queue->front->next;
	  //保存要出队列的数据
	queue->front->next = p->next;       //将下一个结点当作头结点后面链接的第一个结点
	if (queue->rear == p)    //如果要删除的元素即为尾结点，则将头指针赋予尾指针，一同指向头结点，表示队列为空
		queue->rear = queue->front;
    queue->size--;
	delete p;

}

//返回队尾
int Back_SeqQueue(LinkQueue *queue){
    return queue->rear->data;

}
//返回队伍长度
int size_linkqueue(LinkQueue *queue){
    return queue->size;
}

//清空队列
void clear_linkqueue(LinkQueue*queue){

    queue->front = NULL;
    queue->rear  = NULL;

    queue->size = 0;

}
void DestoryQueue(LinkQueue*queue){

    while(!queue){
        queue->rear = queue->front;
        delete queue;
        queue->front = queue->rear;
        queue->size = 0;
    }

}