实验（堆栈）

最新推荐文章于 2022-06-15 22:24:25 发布
最新推荐文章于 2022-06-15 22:24:25 发布
阅读量534 收藏
点赞数
分类专栏： 数据结构基础记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccnuacmhdu/article/details/78847866
版权

本实验主要是栈的基本操作。包括顺序栈，链栈，及用栈实现后缀表达式求值，以及实现括号匹配的检验。
程序代码全部是先给出主函数.cpp代码部分，后面跟着的是.h文件。

顺序栈

#include"sq_stack_test.h"


int main()
{
    sq_stack stack;
    sq_stack_init(stack);
    for (int i = 1; i <= 6; i++) {
        sq_stack_push(stack, i);
        cout << i << "进栈，栈大小为" << sq_stack_length(stack) << "，栈内容："; sq_stack_traverse(stack);
    }
    cout << endl;
    int e;
    while (stack.top != -1) {
        sq_stack_pop(stack, e);
        cout << e << "出栈，栈大小为" << sq_stack_length(stack) << "，栈内容："; sq_stack_traverse(stack);
    }
    return 0;
}
#pragma once
#include<iostream>
#include<string>

using namespace std;

const int SIZE = 100;
typedef int elem_type;

//定义栈
typedef struct {
    int *elem;
    int top;
    int size;
}sq_stack;

void error_message(string s);//提示错误信息
void increment(sq_stack &s);//加长栈空间
void sq_stack_init(sq_stack &s);//初始化栈
void sq_stack_clear(sq_stack &s);//清空栈
void sq_stack_destroy(sq_stack &s);//销毁栈
void sq_stack_push(sq_stack &s, elem_type e);//入栈
void sq_stack_pop(sq_stack &s, elem_type &e);//出栈
void get_sq_stack_top(sq_stack s, elem_type &e);//获取栈顶元素
int sq_stack_length(sq_stack s);//栈长度
bool sq_stack_empty(sq_stack s);//判断栈空
bool sq_stack_full(sq_stack s);//判断栈满
void sq_stack_traverse(sq_stack s);//遍历输出栈

void error_message(string s) {
    cout << s << endl;
}

//加长栈空间
void increment(sq_stack &s) {
    int *p = new int[SIZE + s.size];
    if (!p) error_message("内存分配失败");
    for (int i = 0; i <= s.top; i++)
        p[i] = s.elem[i];
    delete s.elem;
    s.elem = p;
    s.size += SIZE;
}

//初始化栈
void sq_stack_init(sq_stack &s) {
    s.elem = new int[SIZE];
    if (!s.elem) error_message("内存分配失败");
    s.top = -1;
    s.size = SIZE;
}

//销毁栈
void sq_stack_destroy(sq_stack &s) {
    delete s.elem;
}

//清空栈
void sq_stack_clear(sq_stack &s) {
    s.top = -1;
}

//进栈
void sq_stack_push(sq_stack &s, elem_type e) {
    if (s.top + 1 >= s.size) {
        increment(s);
    }
    s.elem[++s.top] = e;
}

//出栈
void sq_stack_pop(sq_stack &s, elem_type &e) {
    if (s.top == -1) {
        cout << "栈已空，不能出栈" << endl;
        return;
    }
    e = s.elem[s.top--];
}

//获取栈顶元素
void get_sq_stack_top(sq_stack &s, elem_type &e) {
    if (s.top == -1) {
        cout << "栈已空，不能获取栈顶元素" << endl;
        return;
    }
    e = s.elem[s.top];
}

//计算栈的长度
int sq_stack_length(sq_stack s) {
    return s.top + 1;
}

//判断栈是否空
bool sq_stack_empty(sq_stack s) {
    return s.top + 1 == 0;
}

//判断栈是否满
bool sq_stack_full(sq_stack s) {
    return s.top + 1 == s.size;
}

void sq_stack_traverse(sq_stack s) {
    elem_type e;
    while (!sq_stack_empty(s)) {
        sq_stack_pop(s, e);
        cout << e << " ";
    }
    cout << endl;
}

链栈

#include"link_stack_test.h"

int main()
{
    link_stack s;
    link_stack_init(s);
    for (int i = 1; i <= 6; i++) {
        cout << i << "入栈"; link_stack_push(s, i); cout << "，栈大小：" << s.size << "，栈内容："; link_stack_traverse(s);
    }
    cout << (link_stack_empty(s) ? "栈已空" : "栈不空") << endl;
    for (int i = 1; i <= 6; i++) {
        int e;
        link_stack_pop(s, e);
        cout << e << "出栈" << ",栈大小:" << s.size << "，栈内容:"; link_stack_traverse(s);
    }
    cout << (link_stack_empty(s) ? "栈已空" : "栈不空") << endl;
    link_stack_destroy(s);
    return 0;
}

#pragma once
#include<iostream>
#include<string>
#include<cstdlib>
using namespace std;

typedef int elem_type;

typedef struct Node1 {
    elem_type data;
    struct Node1 *next;
}node;

typedef struct Node2 {
    int size;
    node *top;
}link_stack;

void error_message(string s);//错误信息输出提示
void link_stack_init(link_stack &s);//链栈初始化
void link_stack_clear(link_stack &s);//清空栈
void link_stack_destroy(link_stack &s);//销毁栈
void link_stack_push(link_stack &s, elem_type e);//入栈
void link_stack_pop(link_stack &s, elem_type &e);//出栈
bool link_stack_empty(link_stack s);//判断栈空
void link_stack_traverse(link_stack s);//遍历栈



void error_message(string s) {
    cout << s << endl;
    exit(-1);
}
void link_stack_init(link_stack &s) {
    s.size = 0;
    s.top = new node;
    if (!s.top) error_message("内存分配失败");
    s.top->next = nullptr;
}

void link_stack_clear(link_stack &s) {
    node *p = s.top->next;
    node *q = nullptr;
    while (p) {
        q = p->next;
        delete p;
        p = q;
    }
    s.top->next = nullptr;
    s.size = 0;
}

void link_stack_destroy(link_stack &s) {
    node *p = s.top->next;
    node *q = nullptr;
    while (p) {
        q = p->next;
        delete p;
        p = q;
    }
    delete s.top;
}

void link_stack_push(link_stack &s, elem_type e) {
    node *tmp = new node;
    if (!tmp) error_message("内存分配失败");
    tmp->data = e;
    tmp->next = s.top->next;
    s.top->next = tmp;
    s.size++;
}

void link_stack_pop(link_stack &s, elem_type &e) {
    if (s.top->next == nullptr) { cout << "栈已空，不能取栈顶元素" << endl; return; }
    e = s.top->next->data;
    node *p = s.top->next;
    s.top->next = p->next;
    delete p;
    s.size--;
}

bool link_stack_empty(link_stack s) {
    return s.size == 0;
}

void link_stack_traverse(link_stack s) {
    node *p = s.top->next;
    while (p) {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

堆栈实验

#include"标头.h"

int main()
{
    go();
    return 0;
}

#pragma once
#include<iostream>
#include<string>
#include<cstdio>
using namespace std;

const int SIZE = 100;
typedef char elem_type;

//定义栈
typedef struct {
    elem_type *elem;
    int top;
    int size;
}sq_stack;

void error_message(string s);//提示错误信息
void increment(sq_stack &s);//加长栈空间
void sq_stack_init(sq_stack &s);//初始化栈
void sq_stack_clear(sq_stack &s);//清空栈
void sq_stack_destroy(sq_stack &s);//销毁栈
void sq_stack_push(sq_stack &s, elem_type e);//入栈
void sq_stack_pop(sq_stack &s, elem_type &e);//出栈
void get_sq_stack_top(sq_stack s, elem_type &e);//获取栈顶元素
int sq_stack_length(sq_stack s);//栈长度
bool sq_stack_empty(sq_stack s);//判断栈空
bool sq_stack_full(sq_stack s);//判断栈满
void sq_stack_traverse(sq_stack s);//遍历输出栈


int suffix_evaluation(char suffix[]);//求后缀表达式的值
void bracket_match(char str[]);//检验括号匹配是否正确


void play_help1();//游戏1提示帮助函数
void play_help2();//游戏2提示帮助函数
void play_help3();//游戏3提示帮助函数
void go1();//玩后缀表达式计算的游戏
void go2();//玩括号匹配检验的游戏
void go3();//玩生成不同排列字符串的游戏
void go();//总的游戏开始
void paly_which();//选择玩哪一个游戏

void error_message(string s) {
    cout << s << endl;
}

//加长栈空间
void increment(sq_stack &s) {
    elem_type *p = new elem_type[SIZE + s.size];
    if (!p) error_message("内存分配失败");
    for (int i = 0; i <= s.top; i++)
        p[i] = s.elem[i];
    delete s.elem;
    s.elem = p;
    s.size += SIZE;
}

//初始化栈
void sq_stack_init(sq_stack &s) {
    s.elem = new elem_type[SIZE];
    if (!s.elem) error_message("内存分配失败");
    s.top = -1;
    s.size = SIZE;
}

//销毁栈
void sq_stack_destroy(sq_stack &s) {
    delete s.elem;
}

//清空栈
void sq_stack_clear(sq_stack &s) {
    s.top = -1;
}

//进栈
void sq_stack_push(sq_stack &s, elem_type e) {
    if (s.top + 1 >= s.size) {
        increment(s);
    }
    s.elem[++s.top] = e;
}

//出栈
void sq_stack_pop(sq_stack &s, elem_type &e) {
    if (s.top == -1) {
        cout << "栈已空，不能出栈" << endl;
        return;
    }
    e = s.elem[s.top--];
}

//获取栈顶元素
void get_sq_stack_top(sq_stack s, elem_type &e) {
    if (s.top == -1) {
        cout << "栈已空，不能获取栈顶元素" << endl;
        return;
    }
    e = s.elem[s.top];
}

//计算栈的长度
int sq_stack_length(sq_stack s) {
    return s.top + 1;
}

//判断栈是否空
bool sq_stack_empty(sq_stack s) {
    return s.top + 1 == 0;
}

//判断栈是否满
bool sq_stack_full(sq_stack s) {
    return s.top + 1 == s.size;
}

//遍历输出栈
void sq_stack_traverse(sq_stack s) {
    elem_type e;
    while (!sq_stack_empty(s)) {
        sq_stack_pop(s, e);
        cout << e << " ";
    }
    cout << endl;
}



//下面是后缀表达式求值

//判断是否是运算符
bool is_operator(char c) {
    if (c == '+' || c == '-' || c == 'X' || c == '/')
        return true;
    return false;
}
//实现加减乘除操作
char calculate(char a, char oper, char b) {
    if (oper == '+') return ((a - '0') + (b - '0')) + '0';
    if (oper == '-') return ((a - '0') - (b - '0')) + '0';
    if (oper == 'X') return ((a - '0')*(b - '0')) + '0';
    if (oper == '/') return ((a - '0') / (b - '0')) + '0';
}

int suffix_evaluation(char suffix[]) {
    sq_stack s;
    sq_stack_init(s);
    char *ch = suffix;
    char c = *ch++;
    while (c != '#') {
        if (!is_operator(c)) sq_stack_push(s, c);
        else {
            char e1, e2;
            sq_stack_pop(s, e1); sq_stack_pop(s, e2);
            sq_stack_push(s, calculate(e2, c, e1)); //此处注意要把后出栈的e2放在前面
                                                    //cout<<calculate(e2,c,e1)<<endl;
        }
        c = *ch++;
    }
    char e3;
    sq_stack_pop(s, e3);
    return e3 - '0';
}
//以上是后缀表达式求值


//括号匹配检验
void bracket_match(char str[]) {
    bool flag = 1;
    char *p = str;
    char c = *p++;
    sq_stack s;
    sq_stack_init(s);
    while (c != '#' && flag) {
        switch (c) {
        case '(':
        case '[': sq_stack_push(s, c); break;
        case ')': {
            char e;
            get_sq_stack_top(s, e);
            if (!sq_stack_empty(s) && e == '(') {
                sq_stack_pop(s, e);
            }
            else {
                flag = 0;
            }
            break;
        }
        case ']': {
            char e;
            get_sq_stack_top(s, e);
            if (!sq_stack_empty(s) && e == '[') {
                sq_stack_pop(s, e);
            }
            else {
                flag = 0;
            }
            break;
        }
        }
        c = *p++;
    }
    if (flag && sq_stack_empty(s)) cout << "括号匹配无误" << endl;
    else cout << "括号匹配有误" << endl;
}


//选择玩哪一个游戏
void play_which() {
    cout << "      ****************选择游戏****************" << endl;
    cout << "      |    请输入以下数字，选择要玩的游戏    |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |1 →后缀表达式求值                    |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |2 →括号匹配检验                      |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |3 →借助栈实现字符串以不同排列方式输出|" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |Q →退出游戏                          |" << endl;
    cout << "      ****************选择游戏****************" << endl;
}

//游戏1（后缀表达式求值）提示帮助
void play_help1() {
    cout << "      *************后缀表达式求值*************" << endl;
    cout << "      |I →输入后缀表达式,要以#结束          |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |注意：只能包含的运算符：+，-，X，/    |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |Q →退出游戏                          |" << endl;
    cout << "      ****************操作提示****************" << endl;
}

//游戏2(括号匹配检验)提示帮助
void play_help2() {
    cout << "      **************括号匹配检验**************" << endl;
    cout << "      |I →输入含括号表达式,要以#结束        |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |注意：只能包含的括号种类：[]()        |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |Q →退出游戏                          |" << endl;
    cout << "      ****************操作提示****************" << endl;
}

//游戏3（给出不同的字符串排列）提示帮助
void play_help3() {
    cout << "      ****************字符排列****************" << endl;
    cout << "      |+X →X入栈                            |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |- →出栈                              |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |E →栈是否已空                        |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |F →栈是否已满                        |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |C →清空栈                            |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |T →遍历栈                            |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |L →栈的大小                          |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |R →强制重新开始游戏                  |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |. →显示输入输出字符顺序              |" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |--------------------------------------|" << endl;
    cout << "      |Q →退出游戏                          |" << endl;
    cout << "      ****************操作提示****************" << endl;
}

//后缀表达式计算
void go1() {
    play_help1();
    char c;
    while (cin >> c) {
        switch (c) {
        case 'I': {
            cout << "请输入一个后缀表达式： "; char s[1000]; scanf("%s", s); cout << suffix_evaluation(s) << endl << endl; break;
        }
        case 'Q':return;
        default:cout << "输入错误，请看操作提示重新输入！" << endl; break;
        }
    }
}

//括号匹配检验
void go2() {
    play_help2();
    char c;
    while (cin >> c) {
        switch (c) {
        case 'I': {
            cout << "请输入一个含括号表达式： "; char s[1000]; scanf("%s", s); bracket_match(s); cout << endl; break;
        }
        case 'Q':return;
        default:cout << "输入错误，请看操作提示重新输入！" << endl; break;
        }
    }
}

//给出不同字符串排列
void go3() {
    play_help3();
    sq_stack sta;
    sq_stack_init(sta);
    char c;
    int cnt1 = 0, cnt2 = 0;
    char str1[1000], str2[1000];
    while (cin >> c) {
        switch (c) {
        case '+':cin >> c; sq_stack_push(sta, c); cout << c << "入栈" << endl; str2[cnt2++] = c; break;
        case '-':
            sq_stack_pop(sta, c); str1[cnt1++] = c; cout << c << "出栈" << endl;
            cout << (sq_stack_empty(sta) ? "栈已空" : "栈不空") << endl;
            break;
        case 'E':cout << (sq_stack_empty(sta) ? "栈已空" : "栈不空") << endl; break;
        case 'F':cout << (sq_stack_full(sta) ? "栈已满" : "栈不满") << endl; break;
        case 'C':sq_stack_clear(sta); cout << (sq_stack_empty(sta) ? "栈已空" : "栈不空") << endl; break;
        case 'L':cout << "栈大小：" << sq_stack_length(sta) << endl; break;
        case 'T':sq_stack_traverse(sta); break;
        case '.':
            str1[cnt1] = '\0'; str2[cnt2] = '\0';
            cout << "入栈顺序： " << str2 << endl;
            cout << "出栈顺序： " << str1 << endl << endl;
            cnt1 = 0; cnt2 = 0;
            break;
        case 'R':cnt1 = cnt2 = 0; sq_stack_clear(sta); cout << "强制重新开始游戏" << endl; break;
        case 'Q':return;
        }
    }
}

void go() {
    play_which();
    char c;
    while (cin >> c) {
        switch (c) {
        case '1':go1(); break;
        case '2':go2(); break;
        case '3':go3(); break;
        case 'Q':return;
        default:cout << "输入错误，请看操作提示重新输入！" << endl; break;
        }
        play_which();
    }
}
Only you, only you!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验 堆栈和队列的应用
12-07
实验五 堆栈和队列的应用 一、实验目的 掌握堆栈和队列的使用。 二、实验内容 1、计算数学表达式的值。 输入数学表达式，输出表达式的计算结果。数学表达式由单个数字和运算符“+”、“-”、“*”、“/”、“(、“)构成，例如 2 + 3 * ( 4 + 5 ) – 6 / 4。假定表达式输入格式合法。 *2、以一个 m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 迷宫根据一个迷宫数据文件建立。迷宫数据文件由一个包含0、1的矩阵组成。迷宫的通路可以使用通路上各点的坐标序列进行展示(使用图形展示最佳)。
数据结构与算法堆栈实验（C++）
qq_46178825的博客
10-17 423
输入一批整形数据，建立一个顺序栈，实现顺序栈的进栈，出栈并打印进栈、出栈前后的顺序栈。 2） 利用顺序栈实现数制的转换。 3） 编写主函数，调试上述算法。 #include<iostream> using namespace std; int push_stack(int *a,int &top,int n)//入栈函数 { a[top++]=n; return 0; } int pop_stack(int *a,int &top)//出栈函数 { int x=a[to.
堆栈实验（压栈，弹栈的Node实现）
m0_46185320的博客
12-15 663
堆栈实验 实验要求： 请设计一个堆栈类Stack，用于存放整数类型 并实现以下方法 public Stack() 构造函数， 创建一个空栈 public boolean empty() 如果栈为空则返回true，否则返回false public int peek() 返回栈顶元素 public int pop() 返回并删除栈顶元素 public int push(int a) 在栈顶增加一个新元素 public int search(int a) 返回栈中指定元素的位置（可以设计栈顶元素的
栈实验
weixin_30621919的博客
04-06 119
node.h #ifndef __NODE_H__ #define __NODE_H__ // 结点类模板 template <class ElemType> struct Node { // 数据成员: ElemType data; // 数据域 Node<ElemType> *next; /...
数据结构-堆栈和队列的实验
hling_so的博客
10-18 1420
堆栈 队列
ARM体系结构数据类型级及寄存器堆栈操作操作实验报告
06-15
ARM体系结构数据类型级及寄存器堆栈操作操作实验报告 ①功能实现： 说明软、硬件的设计思路，并展示实现功能，考核对设计功能的实现程度。 ②结果实现： arm-linux-gcc仿真实现，或S3C6410试验箱硬件实现。 ③实验...
实验二 堆栈和队列基本操作的编程实现
02-09
【实验目的】 堆栈和队列基本操作的编程实现 要求： 堆栈和队列基本操作的编程实现（2学时，验证型），掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选...
RPC DCOM堆栈溢出实验
05-09
实验要求： [实验目的] ◆ 了解堆栈缓冲区溢出的基本原理及其危害。 ◆ 体会远程缓冲区溢出的常见攻击手法。 ◆ 树立安全编程的思想，从根本上杜绝缓冲区溢出的发生。 [实验环境] ◆ 网络：局域网环境。 ◆ 远程...
实验2堆栈模板.rar
06-22
堆栈模板 堆栈模板 堆栈模板 堆栈模板
实验五出现的问题堆栈
程序化人生的随机事件
01-25 413
一、#include是什么意思？malloc函数？ 是一个头文件 声明，要用到其中的函数malloc。 例如： #include #include string.h> #include// main() { char c[11]={"wang"},*str2;//用指针 .. str2=(char*)malloc(sizeof(char));//这里要用到 malloc 申请空间
栈实验报告
03-31
1.了解栈和队列的特性。 2. 掌握栈的顺序表示和实现。 3. 掌握栈的链式表示和实现。 4. 掌握队列的顺序表示和实现。 5. 掌握队列的链式表示和实现。 6. 掌握栈和队列在实际问题中的应用。
数据结构实验——栈的实现及应用
02-12
一、实验目的 1、掌握顺序栈的类型定义方法。 2、掌握在顺序栈上实现的六种基本算法。 2、掌握顺序栈的简单应用。 二、实验内容 1、利用顺序栈将一个非负的十进制整数N转换为对应的B进制数。 [基本要求]非负的十进制整数N和B都从键盘输入；转换结果从屏幕输出。
栈实验（一）行编辑器
08-10
题目描述 一个简单的行编辑程序的功能是：接受用户从终端输入的程序或数据，并存入用户的数据区。 由于用户在终端上进行输入时，不能保证不出差错，因此，若在编辑程序中，“每接受一个字符即存入用户数据区”的做法显然不是最恰当的。较好的做法是，设立一个输入缓冲区，用以接受用户输入的一行字符，然后逐行存入用户数据区。允许用户输入出差错，并在发现有误时可以及时更正。例如，当用户发现刚刚键入的一个字符是错的时，可补进一个退格符"#"，以表示前一个字符无效； 如果发现当前键入的行内差错较多或难以补救，则可以键入一个退行符"@"，以表示当前行中的字符均无效。 如果已经在行首继续输入'#'符号无效。 输入 输入多行字符序列，行字符总数（包含退格符和退行符）不大于250。 输出 按照上述说明得到的输出。 示例输入 whli##ilr#e(s#*s) outcha@putchar(*s=#++);示例输出 while(*s) putchar(*s++);
计算机组成原理堆栈寄存器实验
06-01
计算机组成原理期末时交的课程设计 堆栈寄存器实验 自己做的不是太好 希望有点帮助
栈的实现和应用（实验报告+代码）
04-28
实现了以下三个问题 1、 实现自己的顺序栈类； 2、 判断输入的字符串中的括号是否配对； 3、 输入一个后缀表达式，并进行求值。
栈实验（链式结构）
weixin_45730130的博客
07-25 202
链栈实验（链表实现） 用链式存储实现栈 头文件 #pragma once struct Node { Node* next; int data; }; class LinkStack { public: LinkStack() { top = nullptr; };//构造函数，初始化一个空栈 ~LinkStack();//析构函数 void push(int x);//压栈 void pop();//弹栈 int getTop();//取栈顶元素，不弹栈 bool empty
栈的应用实验
呓语程序缘
10-27 881
一、实验目的 1、掌握栈的基本概念和后入先出的基本特征。 2、掌握栈的基本操作，包括：栈的初始化、销毁、入栈和出栈操作。 二、实验内容 1、采用顺序表初始化空间大小为 50 个字符的栈。 2、完成下列操作，其中 S 为栈，x,y 为字符型变量。 x= "c"; y= "k"; Push(S,x); Push(S, "a"); Push(S,y); Pop(S,x); Push(S, "t"); Push(S,x); Pop(S,x); Push(S, "s"); w
数据结构实验-栈的基本操作
g332273438的博客
06-15 948
数据结构—栈的基本操作（链式储存）（进栈，出栈，遍历，初始化，判空，销毁）
数据结构栈实验
qq_52544734的博客
06-10 353
```c #include<stdio.h> #include<stdlib.h> #include"stack.h" #include"stacklist.h" int main() { int n; int i; int x; char test[100]; do { printf("请选择你想要实现的功能\n"); printf("------1.利用顺序栈将十进制转换为十六进制---------------\n").
arm体系结构数据类型级及寄存器堆栈操作操作实验
最新发布
07-10
ARM体系结构在数据类型级和寄存器堆栈操作方面有许多实验可以进行。数据类型级操作包括对不同数据类型的操作和操作数的大小端模式处理。寄存器堆栈操作主要涉及寄存器的读取、写入和压栈、出栈等操作。 在数据类型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值