数据结构 实验5、链队列的基本操作

（4）验收/测试用例
通过菜单调用各个操作，测试点：
 没有初始化前进行其他操作，程序是否能控制住；
 初始化一个队列；
 判队列空，屏幕显示队列为空；
 4个数入队， 1、2、3、5；
 栈长度，屏幕输出4；
 取队头元素，再判栈空，然后再判栈长度。让学生知道取队头元素不改变队列中的内容，队头指针不发生改变；
 出队，再判栈长度；
 销毁队，再做其他操作，判断程序是否能控制；

//实验5、链队列的基本操作
#include<iostream>
#include<cstdlib>
using namespace std;

typedef struct QNode
{
    int data;
    struct QNode *next;
} QNode, *QueuePtr;

typedef struct LinkQueue
{
    QueuePtr front;
    QueuePtr rear;
};

void xianshi()
{
    cout << "*******************************************************" << endl;
    cout << "**********  1.初始化队列                     **********" << endl;
    cout << "**********  2.销毁队列                       **********" << endl;
    cout << "**********  3.清空队列                       **********" << endl;
    cout << "**********  4.判断队列是否为空               **********" << endl;
    cout << "**********  5.返回队列中元素个数             **********" << endl;
    cout << "**********  6.返回队列队头元素               **********" << endl;
    cout << "**********  7.插入新的队尾元素               **********" << endl;
    cout << "**********  8.删除队头元素                   **********" << endl;
    cout << "**********  9.初始化并创建队列               **********" << endl;
    cout << "**********  10.输出队列元素                  **********" << endl;
    cout << "**********  11.退出                          **********" << endl;
    cout << "*******************************************************" << endl;
    cout << "请输入选择：" << endl;
}

//1.初始化队列
bool InitQueue( LinkQueue & Q )
{
    //生成新结点作为头结点，队头和队尾指针指向此结点
    Q.front = Q.rear = new QNode;
    //头节点的指针域置空
    Q.front->next = NULL;
    return true;
}

//2.销毁队列
bool DestroyQueue( LinkQueue &Q )
{
    while( Q.front != Q.rear )
    {
        delete [](Q.front++);
        return true;
    }
}

//3.清空队列
bool ClearQueue( LinkQueue &Q )
{
    if( Q.front == Q.rear )
        return true;
    else
    {
        Q.front = Q.rear = NULL;
        return true;
    }
}

//4.判断队列是否为空
bool EmptyQueue( LinkQueue Q )
{
    if( Q.front == Q.rear )
        return true;
    else
        return false;
}

//5.返回队列中元素个数
bool LengthQueue ( LinkQueue Q, int &length )
{
    if( EmptyQueue(Q) )
    {
        length = 0;
        return true;
    }
    else
    {
        int len=0;
        while( !EmptyQueue(Q) )
        {
            Q.front = Q.front->next;
            len++;
        }
        length = len;
        return true;
    }
}

//6.返回队列队头元素
bool GetHead( LinkQueue Q, int &e )
{
    if( Q.front == Q.rear )
        return false;
    if( Q.front != Q.rear )
    {
        e = Q.front->next->data;
        return true;
    }

}

//7.插入新的队尾元素
bool EnQueue( LinkQueue &Q, int e )
{
    QNode *p = new QNode;//为入队元素分配结点空间，用指针p指向
    p->data = e;//将新结点数据域置为e
    p->next = NULL;
    Q.rear->next = p;//将新结点插入队尾
    Q.rear = p;//修改队尾指针
    return true;
}

//8.删除队头元素
bool DeQueue(LinkQueue & Q, int &e )
{
    if( EmptyQueue(Q) )
        return false;
    QNode *p = new QNode;
    p = Q.front->next;
    e = p->data;
    Q.front->next = p->next;

    if( Q.rear == p )
        Q.rear = Q.front;
    delete p;
    return true;
}

//9.初始化并创建队列
bool CreateQueue( LinkQueue & Q, int &e )
{
    InitQueue( Q );
    EnQueue( Q, e );
    return true;
}

//10.输出队列元素
bool PrintQueue( LinkQueue Q )
{
    if( EmptyQueue(Q) )
        return false;
    while( !EmptyQueue(Q) )
    {
        cout << (Q.front++)->next->data << ' ';
    }
    cout << endl;
    return true;
}

//11.退出
void exit()
{
    cout << "操作结束，退出成功！" << endl;
    exit(0);
}

void menu()
{
    int operate_num;
    bool continuedo=false;
    LinkQueue Q;

    while( 1 )
    {
        cin >> operate_num;

        switch( operate_num )
        {
        case 1: //1.初始化队列
        {
            if( !continuedo )
            {
                InitQueue(Q);
                printf("链队列初始化成功！\n\n\n");
                continuedo = true;
            }
            else
                printf("链队列已经初始化，不能重复初始化！\n\n\n" );
            break;
        }//case1
        case 2 ://2.销毁队列
        {
            if( continuedo )
            {
                DestroyQueue(Q);
                printf("链队列销毁成功！\n\n\n");
                continuedo = false;
            }
            else
                printf("链队列没有初始化，无法销毁！\n\n\n");
            break;

        }//case2
        case 3://3.清空队列
        {
            if( continuedo )
            {
                ClearQueue(Q);
                printf("链队列清空成功！\n\n\n");
            }
            else
                printf("链队列没有初始化，无法清空！\n\n\n");
            break;
        }//case3
        case 4://判断队列是否为空
        {
            if( continuedo )
            {
                if(EmptyQueue (Q) )
                {
                    printf("链队列为空！\n\n\n");
                }
                else
                    printf("链队列非空！\n\n\n");
            }
            else
                printf("链队列没有初始化，无法判空！\n\n\n");
            break;
        }//case4
        case 5://返回队列中元素个数
        {
            if( continuedo )
            {
                int length;
                LengthQueue(Q, length);
                printf("链队列中的元素个数为：%d。\n\n\n", length);
            }
            else
                printf("链队列没有初始化，无法返回元素个数！\n\n\n");
            break;

        }//case5
        case 6://返回队列队头元素
        {
            if( continuedo )
            {
                int e;
                if( !GetHead(Q,e) )
                {
                    printf("链队列为空，没有队头元素！\n\n\n");
                }
                else
                {

                    GetHead(Q, e);
                    printf("链队列的队头元素为：%d。\n\n\n", e);
                }
            }
            else
                printf("链队列没有初始化，无法取队头元素！\n\n\n");
            break;
        }//case6
        case 7:
        {
            if( continuedo )
            {
                int e;
                cout << "请输入要插入的元素："<< endl;
                cin >> e;
                EnQueue(Q,e);
                printf("元素%d入队成功！\n\n\n", e);
            }
            else
                printf("链队列没有初始化，无法插入队头元素！\n\n\n");
            break;
        }//case 7
        case 8://删除队头元素
        {
            int e;
            if( continuedo )
            {
                if( !DeQueue(Q,e) )
                {
                    printf("链队列为空，无法删除队头元素！\n\n\n");
                }
                else
                    printf("队头元素%d删除成功！", e);
            }
            else
                printf("链队列没有初始化，无法删除队头元素！\n\n\n");
            break;
        }//case 8
        case 9://初始化并创建队列
        {
            int e;
            CreateQueue( Q, e );
            break;
        }//case 9
        case 10://输出队列元素
        {
            if( continuedo )
            {
                PrintQueue(Q);
            }
            else
            {
                printf("链队列没有初始化，无法输出队列元素!\n\n\n");
            }
            break;
        }//case 10
        case 11:
        {
            exit();
            break;
        }
        default:
        {
            cout << "输入操作数有误！" << endl << endl << endl;
            break;
        }//default
        }//switch
    }//while


}//menu()

int main()
{
    xianshi();
    menu();

    return 0;
}