第1关:顺序存储的栈
任务描述
本关要求针对“栈”这一数据结构完成五个操作函数,分别实现判断栈是否为满、是否为空、求栈元素个数、进栈和出栈等功能。
相关知识
栈的基本概念
栈是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算,这一端被称为栈顶。栈既可以采用顺序存储,也可以采用链接存储来实现。下面给出了一种基于顺序存储的栈的实现方案:
图1 顺序存储栈的实现方案
如图1所示:该栈存储了4个元素{56,77,15,12}
,其中12是栈顶元素。
这种实现方案将栈元素存储在一片连续的空间中,栈相关的三个属性元素data
、top
和max
介绍如下:
data
: 给出栈存储空间的起始地址top
: 存放栈顶元素的位置编号max
: 指明栈存储空间中最多可存储的数据元素个数
特别说明:空间的开始地址为 data,连续空间里的位置编号从 data 所指的开始位置起,到该空间的结束位置,编号依次是0,1,2,…,max−1。在图1的示例中max=6。栈顶元素的位置编号由top
给出。
栈结构的定义
基于data
、top
、max
组织成的栈结构如下所示:
struct SeqStack{
T* data; // 数据元素指针
int top; // 栈顶元素编号
int max; // 最大节点数
};
为了讨论简单,我们假设栈元素的数据类型为整数:
typedef int T; // 栈元素的数据类型
据此,只要给定指向该结构的一指针ss
,就可对栈进行进栈出栈操作。
- 进行进栈操作时,新进栈的元素保存在
top+1
位置,进栈后top
加1
,这时的状态则如图 2 所示。
图2 执行进栈操作后栈的状态
- 进行出栈操作时,将位置编号为
top
的元素出栈,出栈后top
减去1
,这时的状态则如图3所示。
图3 执行出栈操作后栈的状态
顺序栈的操作
以顺序栈为例,我们定义如下操作:
(1)创建栈:创建一个最多可以存储maxlen
个元素的顺序栈。具体操作函数定义如下: SeqStack* SS_Create(int maxlen)
(2)释放栈空间:释放栈所占用的空间。具体操作函数定义如下: void SS_Free(SeqStack* ss)
(3)清空一个栈:将栈中元素清空。具体操作函数定义如下: void SS_MakeEmpty(SeqStack* ss)
(4)判断栈是否为满:若栈为满,则返回 true
,否则返回false
。具体操作函数定义如下: bool SS_IsFull(SeqStack* ss)
(5)判断栈是否为空:若栈为空,则返回true
,否则返回false
。具体操作函数定义如下: bool SS_IsEmpty(SeqStack* ss)
(6)求栈元素个数:获取栈元素个数。具体操作函数定义如下: int SS_Length(SeqStack* ss)
(7)将元素x进栈:将x进栈,若满栈则无法进栈,返回false
,否则返回true
。具体操作函数定义如下: bool SS_Push(SeqStack* ss, T x)
(8)出栈:出栈的元素放入item
。若出栈成功(栈不为空),则返回true
;否则(空栈),返回false
。具体操作函数定义如下: bool SS_Pop(SeqStack* ss, T &item)
(9)获取栈顶元素:获取栈顶元素放入item
中。若获取失败(空栈),则返回false
,否则返回true
。具体操作函数定义如下: bool SS_Top(SeqStack* ss, T & item)
(10)打印栈中元素:从栈底到栈顶打印出所有元素。具体操作函数定义如下: void SS_Print(SeqStack* ss)
编程要求
本关任务是实现step1/SeqStack.cpp
中的SS_IsFull
、SS_IsEmpty
、SS_Length
、SS_Push
和SS_Pop
五个操作函数,以实现判断栈是否为满、是否为空、求栈元素个数、进栈和出栈等功能。具体要求如下:
(1) SS_IsFull
:判断栈是否为满,若栈为满,则返回 true
,否则返回false
。
(2)SS_IsEmpty
:判断栈是否为空,若栈为空,则返回true
,否则返回false
。
(3)SS_Length
:获取栈元素个数。
(4)SS_Push
:将元素x
进栈,若满栈则无法进栈,返回false,否则返回true。
(5)SS_Pop:若出栈成功(栈不为空),则返回
true;否则(空栈),返回
false`。
输入输出格式请参见后续说明及测试样例。
注意:本关必读中提及的其他操作已经由平台实现,你在实现本关任务的五个操作函数时,在函数体内可调用其他操作。`
测试说明
本关的测试文件是step1/Main.cpp
,负责对你实现的代码进行测试。输入输出说明:
输入格式: 首先输入一个正整数max
,创建一个最多可存储max
个元素的栈。然后输入多个操作:如果输入”push
”,则后面跟一个数x
,表示x
进栈;如果输入”pop
”,表示出栈操作;如果输入”end
”,表示输入结束。
输出格式: 输出栈的长度,然后从栈底到栈顶依次输出各元素。
样例输入:
6
push 56
push 15
push 12
push 13
pop
end
样例输出
Stack length: 3
stack data (from bottom to top): 56 15 12
上答案:
/*************************************************************
date: July 2017
copyright: Zhu En(祝恩)
DO NOT distribute this code.
**************************************************************/
//顺序存储的栈 实现文件
/
#include <stdio.h>
#include <stdlib.h>
#include "SeqStack.h"
/*创建一个栈*/
SeqStack* SS_Create(int maxlen)
{
SeqStack* ss=(SeqStack*)malloc(sizeof(SeqStack));
ss->data=(T*)malloc(maxlen*sizeof(T));
ss->top=-1;
ss->max=maxlen;
return ss;
}
/*释放一个栈*/
void SS_Free(SeqStack* ss)
{
free(ss->data);
free(ss);
}
/*清空一个栈*/
void SS_MakeEmpty(SeqStack* ss)
{
ss->top=-1;
}
/*判断栈是否为满*/
bool SS_IsFull(SeqStack* ss)
{
/*请在BEGIN和END之间实现你的代码*/
/*****BEGIN*****/
return ss->top+1>=ss->max;
/******END******/
}
/*判断栈是否为空*/
bool SS_IsEmpty(SeqStack* ss)
{
/*请在BEGIN和END之间实现你的代码*/
/*****BEGIN*****/
return ss->top<0;
/******END******/
}
/*获取栈元素个数*/
int SS_Length(SeqStack* ss)
{
/*请在BEGIN和END之间实现你的代码*/
/*****BEGIN*****/
return ss->top+1;
/******END******/
}
/*将x进栈,满栈则无法进栈(返回false)*/
bool SS_Push(SeqStack* ss, T x)
{
/*请在BEGIN和END之间实现你的代码*/
/*****BEGIN*****/
if(SS_IsFull(ss)){
return false;
}
ss->top++;
ss->data[ss->top]=x;
return 0;
/******END******/
}
/*出栈,出栈的元素放入item,空栈则返回false*/
bool SS_Pop(SeqStack* ss, T &item)
{
/*请在BEGIN和END之间实现你的代码*/
/*****BEGIN*****/
if(SS_IsEmpty(ss)){
return false;
}
item=ss->data[ss->top];
ss->top--;
return 0;
/******END******/
}
/*获取栈顶元素放入item中,空栈则返回false*/
bool SS_Top(SeqStack* ss, T & item)
{
if (SS_IsEmpty(ss)) {
return false;
}
item = ss->data[ss->top];
return true;
}
/*从栈底到栈顶打印出所有元素*/
void SS_Print(SeqStack* ss)
{
if (SS_IsEmpty(ss)) {
printf("stack data: Empty!\n");
return;
}
printf("stack data (from bottom to top):");
int curr=0;
while(curr<=ss->top) {
printf(" %d", ss->data[curr]);
curr++;
}
//printf("\n");
}
第2关:实现一个链接存储的栈
任务描述
本关任务要求针对以链接存储方式实现的栈这一数据结构,完成五个操作函数,分别实现判断栈是否为空、求栈的长度、进栈、出栈以及获取栈顶元素等功能。
相关知识
链接存储的栈
栈的存储也可以采用链接存储的方式来实现。下面给出了一种基于链接存储的栈的实现方案:
如图1所示:该栈存储了3
个元素{56,77,15}
,其中56
是栈顶元素。
这种实现方案中与栈相关的两个属性元素top
和len
介绍如下:
top
: 指向栈顶结点的指针len
: 栈中结点的个数
特别说明:链接存储方式下,链表头结点作为栈顶结点,用指针
top指向栈顶结点,栈结点个数由
len给出。
基于top
和len
组织成的栈结构如下:
struct LinkStack {
LNode* top; // 栈顶指针
int len; // 栈的长度
};
为了讨论简单,我们假设栈元素的数据类型为整数:
typedef int T; // 栈元素的数据类型
同时,每个结点的结构定义为:
struct LNode {
T data;
LNode* next;
};
据此,只要给定指向该结构的一指针ls
,就可对栈进行出栈操作。
- 进行出栈操作时,将指针top指向的当前栈顶元素56出栈,出栈后
top
指向下一个栈顶元素77,这时的状态则如图2所示。
针对链式栈我们定义如下操作:
-
创建栈:创建一个链式栈。具体操作函数定义如下:
LinkStack* LS_Create()
-
释放栈:释放栈所占用的空间。具体操作函数定义如下:
void LS_Free(LinkStack* ls)
-
清空一个栈:将链式栈变为空栈。具体操作函数定义如下:
void LS_MakeEmpty(LinkStack* ls)
-
判断栈是否为空:若栈为空,则返回
true
,否则返回false
。具体操作函数定义如下:bool LS_IsEmpty(LinkStack* ls)
-
求栈的长度:获取链式栈的长度。具体操作函数定义如下:
int LS_Length(LinkStack* ls)
-
将元素x进栈:将x进栈,若满栈则无法进栈,具体操作函数定义如下:
void LS_Push(LinkStack* ls, T x)
-
出栈:出栈的元素放入
item
。若出栈成功(栈不为空),则返回true
;否则(空栈),返回false
。具体操作函数定义如下:bool LS_Pop(LinkStack* ls, T& item)
-
获取栈顶元素:获取栈顶元素放入
item
中。若获取失败(空栈),则返回false
,否则返回true
。具体操作函数定义如下:bool LS_Top(LinkStack* ls, T& item)
-
打印栈中元素:从栈顶到栈底打印各结点数据元素。具体操作函数定义如下:
void LS_Print(LinkStack* ls)
编程要求
本关任务是实现step2/LnkStack.cpp
中的LS_IsEmpty
、LS_Length
、LS_Push
、LS_Pop
和LS_Top
五个操作函数,以实现判断栈是否为空、求栈的长度、进栈、出栈以及获取栈顶元素等功能。具体要求如下:
-
LS_IsEmpty:判断栈是否为空,若栈为空,则返回true,否则返回false。
-
LS_Length:获取链式栈的长度。
-
LS_Push:将元素x进栈,若满栈则无法进栈,返回false,否则返回true。
-
LS_Pop:若出栈成功(栈不为空),则返回true;否则(空栈),返回false。
-
LS_Top:获取栈顶元素。
-
输入输出格式请参见后续说明及测试样例。
注意:本关必读中提及的其他操作已经由平台实现,你在实现本关任务的五个操作函数时,在函数体内可调用其他操作。
本关涉及的代码文件LnkStack.cpp
中的5个操作函数的代码框架如下:
bool LS_IsEmpty(LinkStack* ls)
// 判断栈是否为空。为空返回true,否则返回false。
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
/********** End **********/
}
int LS_Length(LinkStack* ls)
// 获取栈的长度
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
/********** End **********/
}
void LS_Push(LinkStack* ls, T x)
// 将元素x进栈
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
/********** End **********/
}
bool LS_Pop(LinkStack* ls, T& item)
// 出栈的元素放入item。若出栈成功(栈不为空),则返回true;否则(空栈),返回false。
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
/********** End **********/
}
bool LS_Top(LinkStack* ls, T& item)
// 获取栈顶元素,若获取失败(空栈),则返回false,否则返回true。
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
/********** End **********/
}
测试说明
本关的测试文件是step2/Main.cpp
,负责对你实现的代码进行测试。具体代码如下:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "LnkStack.h"
#pragma warning(disable:4996)
void main()
{
LinkStack* ls=LS_Create();
char dowhat[100];
while(true) {
scanf("%s", dowhat);
if (!strcmp(dowhat,"push")) {
T x;
scanf("%d", &x);
LS_Push(ls,x);
}else if (!strcmp(dowhat,"pop")) {
T item;
LS_Pop(ls, item);
}
else {
break;
}
}
int length=LS_Length(ls);
printf("Stack length: %d\n", length);
LS_Print(ls);
LS_Free(ls);
system("PAUSE");
}
注意:step2/Main.cpp的代码不能被修改。
输入输出说明: 输入格式: 输入多个操作:如果输入”push
”,则后面跟一个数x
,表示x
进栈;如果输入”pop
”,表示出栈操作;如果输入”end
”,表示输入结束。
输出格式: 输出栈的长度,然后从栈底到栈顶依次输出各元素。
以下是平台对step2/Main.cpp
的测试样例:
样例输入:
push 56
push 15
push 12
push 13
pop
end
样例输出
Stack length: 3
The stack (from top to bottom): 12 15 56
上答案:
/*************************************************************
date: June 2017
copyright: Zhu En(祝恩)
DO NOT distribute this code.
**************************************************************/
// 链接存储的栈实现文件
#include <stdio.h>
#include <stdlib.h>
#include "LnkStack.h"
/*创建栈*/
LinkStack* LS_Create()
{
LinkStack* ls=(LinkStack*)malloc(sizeof(LinkStack));
ls->top = NULL;
ls->len = 0;
return ls;
}
/*释放栈*/
void LS_Free(LinkStack* ls)
{
LNode* curr = ls->top;
while(curr) {
LNode* next = curr->next;
free(curr);
curr=next;
}
free(ls);
}
/*将栈变为空栈*/
void LS_MakeEmpty(LinkStack* ls)
{
LNode* curr = ls->top;
while(curr) {
LNode* next = curr->next;
free(curr);
curr=next;
}
ls->top = NULL;
ls->len = 0;
}
/*判断栈是否为空*/
bool LS_IsEmpty(LinkStack* ls)
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
return ls->len==0;
/********** End **********/
}
/*获取栈的长度*/
int LS_Length(LinkStack* ls)
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
return ls->len;
/********** End **********/
}
/*将x进栈*/
void LS_Push(LinkStack* ls, T x)
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
LNode*node=(LNode*)malloc(sizeof(LNode));
node->data=x;
node->next=ls->top;
ls->top=node;
ls->len++;
/********** End **********/
}
/*出栈。出栈元素放入item;如果空栈,将返回false*/
bool LS_Pop(LinkStack* ls, T& item)
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
LNode*node=ls->top;
if(node==NULL){
return false;
}
item=node->data;
ls->top=node->next;
ls->len--;
free(node);
return 0;
/********** End **********/
}
/*读栈顶元素放入item。如果空栈,将返回false*/
bool LS_Top(LinkStack* ls, T& item)
{
// 请在这里补充代码,完成本关任务
/********** Begin *********/
LNode*node=ls->top;
if(node==NULL){
return false;
}
item=node->data;
return 0;
/********** End **********/
}
/*从栈顶到栈底打印各结点数据*/
void LS_Print(LinkStack* ls)
{
if (ls->len==0){
printf("The stack: Empty!");
return;
}
printf("The stack (from top to bottom):");
LNode* curr=ls->top;
while(curr) {
printf(" %d", curr->data);
curr=curr->next;
}
// printf("\n");
}