合肥工业大学 宣城校区 数据结构与算法实验 队列、二叉树、查找和排序

队列

1.实验目标

熟练掌握队列的顺序存储结构和链式存储结构。
熟练掌握队列的有关算法设计，并在循环顺序队列和链队列上实现。
根据具体给定的需求，合理设计并实现相关结构和算法。

2.实验内容和要求

循环顺序队列的实验要求
循环顺序队列结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；
实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；
程序有适当的注释。

链队列实验要求
本次实验中的链队列结构指不带头结点的单链表；
链队列结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；
实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；
程序有适当的注释。

循环顺序队列实验任务
<1>初始化一个队列。
<2>判断是否队空。
<3>判断是否队满。
设队列最大长度：MaxLen=100
第一组数据：入队n个元素，判断队满
第二组数据：用循环方式将1到99，99个元素入队，判队满
<4>入队
第一组数据：4，7，8，12，20，50
第二组数据：a,b,c,d,f,g
<5>出队
<6>取队头元素
<7>求当前队列中元素个数
<8>编写算法实现
①初始化空循环队列；
②当键盘输入奇数时，此奇数入队；
③当键盘输入偶数时，队头出队；
④当键盘输入0时，算法退出；
⑤每当键盘输入后，输出当前队列中的所有元素。

链队列实验任务
<1>初始化一个队列。
<2>判断是否队空。
<3>判断是否队满。
设队列最大长度：MaxLen=100
第一组数据：入队n个元素，判断队满
第二组数据：用循环方式将1到99，99个元素入队，判队满
<4>入队
第一组数据：4，7，8，12，20，50
第二组数据：a,b,c,d,f,g
<5>出队
<6>取队头元素
<7>求当前队列中元素个数
<8>编写算法实现
①初始化空循环队列；
②当键盘输入奇数时，此奇数入队；
③当键盘输入偶数时，队头出队；
④当键盘输入0时，算法退出；
⑤每当键盘输入后，输出当前队列中的所有元素。

3.数据结构设计文章来源地址https://www.toymoban.com/news/detail-501326.html

#ifndef QUEUELIST_H_INCLUDED
#define QUEUELIST_H_INCLUDED
#include<stdio.h>
#include<stdlib.h>
#define maxlen 100

typedef struct squeue
{
   
    int data[maxlen];
    int lfront;
    int lrear;
}seqqueue;

typedef struct cqueue
{
   
    char data[maxlen];
    int lfront;
    int lrear;
}seqcqueue;

typedef struct lnode
{
   
    int data;
    struct lnode *next;
}node;

typedef struct
{
   
    node *sfront;
    node *srear;
}linkqueue;

typedef struct lcnode
{
   
    char data;
    struct lcnode *next;
}cnode;

typedef struct
{
   
    cnode *cfront;
    cnode *crear;
}linkcqueue;

void initialqueue(seqqueue q);
int queueempty(seqqueue q);
int queuefull(seqqueue q);
void enqueue(seqqueue q,int x);
void outqueue(seqqueue q);
void queuefront(seqqueue q,int x);
void queueall(seqqueue q);
void ssqueue(seqqueue q);
void encqueue(seqcqueue q,char x);

void initqueue(linkqueue q);
int queuelempty(linkqueue q);
int queuelfull(linkqueue q);
void enlqueue(linkqueue q,int x);
void outlqueue(linkqueue q);
void queuelfront(linkqueue q,int x);
void queuelall(linkqueue q);
void sslqueue(linkqueue q);
void enclqueue(linkcqueue q,char a);

seqqueue creatqueue(void)
{
   
    seqqueue l;
    int x;

    l.lfront = 0;
    l.lrear = 0;

    printf("向队列中输入元素。（输入9999停止）\n");
    scanf("%d",&x);
    while(x!=9999)
    {
   
        l.lrear = ((l.lrear+1)%maxlen);
        l.data[l.lrear] = x;
        scanf("%d",&x);
    }
    return l;
}

seqcqueue creatcqueue(void)
{
   
    seqcqueue l;
    char x;

    l.lfront = 0;
    l.lrear = 0;

    printf("向队列中输入元素。（输入0停止）\n");
    scanf("%s",&x);
    while(x!='0')
    {
   
        l.lrear = ((l.lrear+1)%maxlen);
        l.data[l.lrear] = x;
        scanf("%s",&x);
    }
    return l;
}

linkqueue creatlqueue(void)
{
   
    linkqueue l;
    int x;
    node *p,*r;
    l.sfront = (node *)malloc(sizeof(node));
    l.srear = l.sfront;
    l.sfront->next = NULL;
    r = l.sfront;

    printf("向队列中输入元素。（输入9999停止）\n");
    scanf("%d",&x);
    while(x!=9999)
    {
   
        p = (node *)malloc(sizeof(node));
        p->data = x;
        p->next = NULL;
        l.srear = p;
        r->next = p;
        r = p;
        scanf("%d",&x);
    }
    return l;
}

linkcqueue creatclqueue(void)
{
   
    linkcqueue l;
    char x;
    cnode *p;
    l.cfront = (cnode *)malloc(sizeof(cnode));
    l.crear = l.cfront;
    l.cfront->next = NULL;

    printf("向队列中输入元素。（输入0停止）\n");
    scanf("%c",&x);

    while(x!='0')
    {
   
        p = (cnode *)malloc(sizeof(cnode));
        p->data = x;
        p->next = NULL;
        l.crear->next = p;
        l.crear = p;
        scanf("%c",&x);
    }
    return l;
}

void menu(void)
{
   
    int m;
    loop:
    printf("循环顺序队列实验任务：\n");
    printf("<1>初始化一个队列。\n");
    printf("<2>判断是否队空。\n");
    printf("<3>判断是否队满。\n");
    printf("<4>入队。（数字）\n");
    printf("<5>入队。（字母）\n");
    printf("<6>出队。\n");
    printf("<7>取队头元素。\n");
    printf("<8>求当前队列中元素个数。\n");
    printf("<9>编写算法实现功能。\n");
    printf("\n");

    printf("链队列实验任务：\n");
    printf("<10>初始化一个队列。\n");
    printf("<11>判断是否队空。\n");
    printf("<12>判断是否队满。\n");
    printf("<13>入队。（数字）\n");
    printf("<14>入队。（字母）\n");
    printf("<15>出队。\n");
    printf("<16>取队头元素。\n");
    printf("<17>求当前队列中元素个数。\n");
    printf("<18>编写算法实现功能。\n");
    printf("\n");

    printf("<19>清屏。\n");
    printf("<20>退出。\n");
    printf("\n");

    scanf("%d",&m);
    printf("\n");

    switch(m)
    {
   
        case 1:
            {
   
                seqqueue q;
                q = creatqueue();
                initialqueue(q);
                goto loop;
            }
        case 2:
            {
   
                seqqueue q;
                q = creatqueue();
                queueempty(q);
                goto loop;
            }
        case 3:
            {
   
                seqqueue q;
                q = creatqueue();
                queuefull(q);
                goto loop;
            }
        case 4:
            {
   
                seqqueue q;
                int x;
                q = creatqueue();
                printf("输入入队元素。\n");
                scanf("%d",&x);
                enqueue(q,x);
                goto loop;
            }
        case 5:
            {
   
                seqcqueue q;
                char x;
                q = creatcqueue();
                printf("输入入队元素。\n");
                scanf("%s",&x);
                encqueue(q,x);
                goto loop;
            }
        case 6:
            {
   
                seqqueue q;
                q = creatqueue();
                outqueue(q);
                goto loop;
            }
        case 7:
            {
   
                seqqueue q;
                int x;
                q = creatqueue();
                queuefront(q,x);
                goto loop;
            }
        case 8:
            {
   
                seqqueue q;
                q = creatqueue();
                queueall(q);
                goto loop;
            }
        case 9:
            {
   
                seqqueue q;
                q = creatqueue();
                ssqueue(q);
                goto loop;
            }
        case 10:
            {
   
                linkqueue l;
                l = creatlqueue();
                initqueue(l);
                goto loop;
            }
        case 11:
            {
   
                linkqueue l;
                l = creatlqueue();
                queuelempty(l);
                goto loop;
            }
        case 12:
            {
   
                linkqueue l;
                l = creatlqueue();
                queuelfull(l);
                goto loop;
            }
        case 13:
            {
   
                linkqueue l;
                int x;
                l = creatlqueue();
                printf("输入入队元素。\n");
                scanf("%d",&x);
                enlqueue(l,x);
                goto loop;
            }
        case 14:
            {
   
                linkcqueue l;
                char x;
                l = creatclqueue();
                printf("输入入队元素。\n");
                getchar();
                scanf("%c",&x);
                enclqueue(l,x);
                goto loop;
            }
        case 15:
            {
   
                linkqueue l;
                l = creatlqueue();
                outlqueue(l);
                goto loop;
            }
        case 16:
            {
   
                linkqueue l;
                int x;
                l = creatlqueue();
                queuelfront(l,x);
                goto loop;
            }
        case 17:
            {
   
                linkqueue l;
                l = creatlqueue();
                queuelall(l);
                goto loop;
            }
        case 18:
            {
   
                linkqueue l;
                l = creatlqueue();
                sslqueue(l);
                goto loop;
            }
        case 19:
            {
   
                system("cls");
                goto loop;
            }
        case 20:
            {
   
                goto mmo;
            }
        default:
            {
   
                printf("输入错误。\n");
                system("pause");
                goto loop;
            }
    }
    mmo:system("cls");
}

void initialqueue(seqqueue q) //<1>初始化一个队列。
{
   
    q.lfront = 0;
    q.lrear = 0;
    printf("初始化完成。\n");
    system("pause");
}

int queueempty(seqqueue q) //<2>判断是否队空。
{
   
    if(q.lfront==q.lrear)
    {
   
        printf("队列为空。\n");
        system("pause");
        return 1;
    }
    else
    {
   
        printf("队列不为空。\n");
        system("pause");
        return 0;
    }
}

int queuefull(seqqueue q) //<3>判断是否队满。
{
   
    if(((q.lrear+1)%maxlen)==q.lfront)
    {
   
        printf("队列为满。\n");
        system("pause");
        return 1;
    }
    else
    {
   
        printf("队列未满。\n");
        system("pause");
        return 0;
    }
}

void enqueue(seqqueue q,int x) //<4>入队
{
   
    int i;
    if(((q.lrear+1)%maxlen)==q.lfront)
    {
   
        printf("队列已满。\n");
        system("pause");
    }
    else
    {
   
        q.lrear = ((q.lrear+1)%maxlen);
        q.data[q.lrear] = x;
        for(i=q.lfront+1;i<=q.lrear;i=i+1)
        {
   
            printf("%d\t",q.data[i]);
        }
        printf("\n");
        system("pause");
    }
}

void encqueue(seqcqueue q,char x) //<4>入队
{
   
    int i;
    if(((q.lrear+1)%maxlen)==q.lfront)
    {
   
        printf("队列已满。\n");
        system("pause");
    }
    else
    {
   
        q.lrear = ((q.lrear+1)%maxlen);
        q.data[q.lrear] = x;
        for(i=q.lfront+1;i<=q.lrear;i=i+1)
        {
   
            printf("%c\t",q.data[i]);
        }
        printf("\n");
        system("pause");
    }
}

void outqueue(seqqueue q) //<5>出队
{
   
    int i;
    if(((q.lrear+1)%maxlen)==q.lfront)
    {
   
        printf("队列为空。\n");
        system("pause");
    }
    else
    {
   
        q.lfront = (q.lfront+1)%maxlen;
        for(i=q.lfront+1;i<=q.lrear;i=i+1)
        {
   
            printf("%d\t",q.data[i]);
        }
        printf("\n");
        system("pause");
    }
}

void queuefront(seqqueue q,int x) //<6>取队头元素
{
   
    if(q.lfront==q.lrear)
    {
   
        printf("队列为空。\n");
        system("pause");
    }
    else
    {
   
        x = q.data[(q.lfront+1)%maxlen];
        printf("队头元素为：%d\n",x);
        system("pause");
    }
}

void queueall(seqqueue q) //<7>求当前队列中元素个数
{
   
    int i,x;
    x = q.lfront;

    for(i=0;x<q.lrear;x=x+1)
    {
   
        i = i+1;
    }

    printf("队列中的元素个数为：%d\n",i);
    system("pause");
}

void ssqueue(seqqueue q) //<8>编写算法实现
{
   
    int i=0,x,j,k;
    q.lfront = 0;
    q.lrear = 0;

    printf("向队列输入元素。（输入0后退出）\n");
    scanf("%d",&x);
    while(x!=0)
    {
   
        if(x%2==0)
        {
   
            if(i>0)
            {
   
                q.lfront = (q.lfront+1)%maxlen;
                i = i-1;
            }
            else
            {
   
                printf("当前队列为空。");
            }
        }
        else if(x%2!=0)
        {
   
            q.lrear = (q.lrear+1)%maxlen;
            q.data[q.lrear] = x;
            i = i+1;
        }

        k = q.lfront+1;
        for(j=0;j<i;j=j+1)
        {
   
            printf("%d\t",q.data[k]);
            k = k+1;
        }
        printf("\n\n");
        scanf("%d",&x);
    }
}

void initqueue(linkqueue q) //<1>初始化一个队列。
{
   
    node *p,*s;
    p = q.sfront->next;
    s = p->next;
    q.sfront->next = NULL;
    while(p!=q.srear)
    {
   
        free(p);
        p = s;
        s = s->next;
    }
    q.srear = q.sfront;
    printf("初始化完成。\n");
    system("pause");
}

int queuelempty(linkqueue q) //<2>判断是否队空。
{
   
    if(q.srear==q.sfront)
    {
   
        printf("队列为空。\n");
        system("pause");
        return 1;
    }
    else
    {
   
        printf("队列不为空。\n");
        system("pause");
        return 0;
    }
}

int queuelfull(linkqueue q) //<3>判断是否队满。
{
   
    int i=0;
    node *s;

    s = q.sfront->next;
    while(s!=NULL)
    {
   
        i = i+1;
        s = s->next;
    }

    if(i==100)
    {
   
        printf("队列已满。\n");
        system("pause");
        return 1;
    }
    else
    {
   
        printf("队列未满。\n");
        system("pause");
        return 0;
    }
}

void enlqueue(linkqueue q,int x) //<4>入队
{
   
    node *p;
    p = (node *)malloc(sizeof(node));

    p->data = x;
    p->next = NULL;
    q.srear->next = p;
    q.srear = p;

    p = q.sfront->next;
    while(p!=NULL)
    {
   
        printf("%d\t",p->data);
        p = p->next;
    }
    printf("\n");
    system("pause");
}

void enclqueue(linkcqueue q,char a)
{
   
    cnode *p,*u;

    p = (cnode *)malloc(sizeof(cnode));
    p->data = a;
    p->next = NULL;
    q.crear->next = p;
    q.crear = p;

    u = q.cfront->next;
    while(u!=NULL)
    {
   
        printf("%c",u->data);
        u = u->next;
    }
    printf("\n");
    system("pause");
}

void outlqueue(linkqueue q) //<5>出队
{
   
    node *u,*p;
    int x;
    if(q.srear==q.sfront)
    {
   
        printf("队列为空。\n");
        system("pause");
    }
    else
    {
   
        x = q.sfront->next->data;
        u 

到了这里，关于合肥工业大学 宣城校区 数据结构与算法实验 队列、二叉树、查找和排序的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！