栈和队列研究-数据结构c++

一、实验目的：

（1）综合应用栈和队列的存储结构设计及基本操作。

（2）分析实际问题中具有栈和队列特点的数据结构。

二、过程要求（题目背景）

（1）编写栈的基本操作函数，并在main主函数中来实现数制转换的应用。

①初始化栈操作。

②进栈操作。

③出栈操作。

④判栈空操作。

⑤数制转换操作。

问题描述：输入一个十进制数，输出其相应的八进制数。

（2）编写队列的基本操作函数，并在main主函数中来实现队列管理模拟的程序。

①队列管理的模拟算法，要求：队列采用带头结点的链表结构。

②队列初始化为空队列。

③键盘输入奇数时，奇数从队尾入队列。

④键盘输入偶数时，队头指针指向的奇数出队列。

⑤键盘输入0，退出算法。

⑥每输入一整数，显示操作后队列中的值。

三、可执行程序（程序清单）：

（1）

#include <iostream>

#include <stdio.h>

#include <stdlib.h>

using namespace std;



#define TRUE 1

#define FALSE 0

#define STACK_INIT_SIZE 100

#define STACKINCREMENT 10

#define OK 1;

#define OVERFLOW -2

#define ERROR 0;



typedef int Status;

typedef int SElemType;

typedef struct

{

    SElemType* base;

    SElemType* top;

    int stacksize;

}SqStack;

Status InitStack(SqStack& S)//初始化

{

    S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(STACK_INIT_SIZE));

    if (!S.base)

        exit(OVERFLOW);

    S.top = S.base;

    S.stacksize = STACK_INIT_SIZE;

    return OK;

}

Status Push(SqStack& S, SElemType e)//入栈

{

    if (S.top - S.base >= S.stacksize)

    {

        S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));

        if (!S.base)

            exit(OVERFLOW);

        S.top = S.base + S.stacksize;

        S.stacksize += STACKINCREMENT;

    }

    *(S.top++) = e;

    return OK;

}

Status Pop(SqStack& S, SElemType& e)//出栈

{

    if (S.top == S.base)

        return ERROR;

    e = *--S.top;

    return OK;

}

Status StackEmpty(SqStack S)//判栈空

{

    if (S.base == S.top)

        return TRUE;

    else

        return FALSE;

}

void conversion(int N)//八进制转换

{

    SqStack S;

    SElemType e;

    InitStack(S);

    while (N)

    {

        Push(S, N %8);

        N = N / 8;

    }

    while (S.top != S.base)

    {

        Pop(S, e);

        cout<<e;

    }

}

int main()

{

    int n;

    cout << "输入十进制数" << endl;

    cin>>n;

    cout << "对应八进制数为" << endl;

    conversion(n);

    return 0;

}

（2）

#include <iostream>

#include <stdio.h>

#include <stdlib.h>

using namespace std;

typedef int Status;

#define OVERFLOW -1

constexpr auto OK = 1;

#define ERROR 0

typedef int  QElemType;

typedef struct Qnode

//链队列存储

{

    QElemType data;

    struct Qnode* next;

} QNode, * QueuePtr;



typedef struct

//指针链

{

    QueuePtr front;

    //头指针

    QueuePtr rear;

    //尾指针

} LinkQueue;



Status InitQueue(LinkQueue& Q)

//建立 初始化

{

    Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));

    if (!Q.front)   exit(OVERFLOW);

    Q.front->next = NULL;



    return OK;

}

Status EnQueue(LinkQueue& Q, QElemType e)

//入队

{

    QNode* p;



    p = (QueuePtr)malloc(sizeof(QNode));//分配一个结点

    if (!p) exit(OVERFLOW);



    p->data = e;                        //为结点各域赋值

    p->next = NULL;



    Q.rear->next = p;                   //插入

    Q.rear = p;



    return OK;

}

Status DeQueue(LinkQueue& Q, QElemType& e)

{

    QNode* p;

    if (Q.front == Q.rear) return ERROR;//判断队空

    p = Q.front->next;    e = p->data;//取得队头元素值

    Q.front->next = p->next;//删除队头元素

    if (Q.rear == p) Q.rear = Q.front;//为队尾指针赋值

    free(p);//释放空间

    return OK;

}

void output(LinkQueue Q)//输出函数

{

    QNode* p;

    if (Q.front == Q.rear)cout << "为空" << endl;

    else

    {

        p = Q.front->next;

        cout << "队列为:";

        while (p != NULL)

        {

            cout << p->data<<" ";

            p = p->next;

        }

        cout << endl;

    }

}

void free_1(LinkQueue& Q)

{

    Qnode* p;

    while (Q.front)

    {

        Q.rear = Q.front->next;

        free(Q.front);

        Q.front = Q.rear;

     }

}

int main()

{

    LinkQueue Q;

    InitQueue(Q);

    int n,e;

    cout << "输入";

    cin >> n;

    while (n!=0)

    {

        if (n % 2 != 0)

        {

            cout << "入队" << endl;

            EnQueue(Q, n);

        }

        else

        {

            cout << "出队" << endl;

            DeQueue(Q, e);

        }

        output(Q);

        cout << "输入:";

        cin >> n;

    }

    cout << "销毁"<<endl;

    free_1(Q);

    cout << "销毁完成" << endl;

    output(Q);

}

四、运行结果：

（1）

（2）

五、心得：

（1）掌握进制转换的数学算法；函数修改数据时需取地址

（2）使用队列或其他时，选先初始化为其分配空间，使用完成后销毁