数据结构遍历顺序栈_小蚂蚁学习数据结构（28）——题目——顺序栈的遍历输出...

已知栈的顺序存储结构定义如下：

typedef int SElemType;

typedef struct{

SElemType * base;

SElemType * top;

int stacksize;

}SqStact;

下面是依次弹出栈中的所有元素、并逐个输出的类C_算法，操作的结果使栈变成空栈，请填空

void Pop_Print_Sq(SqStack &S);

/*

顺序栈的操作

题目要求：依次弹出栈中元素、并逐个输出的类C算法。

*/

# include 

# include 

# define ERROR 0

# define OK   1

# define STACK_INIT_SIZE 5

# define STACKINCREMENT  1

typedef char Elemtype;

typedef int  Status;

typedef struct stack

{

Elemtype * base;//栈底指针

Elemtype * top;//栈顶指针

int stacksize;//栈总空间

}SqStack;

//栈操作函数前置声明

//初始化一个栈

Status InitStack( SqStack & );

//销毁这个栈

Status DestroyStack( SqStack & );

//清空这个栈

Status ClearStack( SqStack & );

//判断这个栈是否为空

bool StackEmtpy( SqStack & );

//返回这个栈的长度

Status StackLength( SqStack & );

//得到栈顶元素

Status GetTop( SqStack &, Elemtype & );

//往栈中压入一个元素

Status Push( SqStack &, Elemtype );

//弹出一个元素，并且返回弹出元素的值

Status Pop( SqStack &, Elemtype & );

//遍历整个栈

Status StackTraverse( SqStack & );

//题目要求的函数

void Pop_Print_Sq( SqStack & );

//初始化这个栈

Status InitStack( SqStack & S )

{

/*

为栈指针分配空间

PS：malloc分配空间这里，超出后也正常的原因需要重点标注一下。

*/

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

if( NULL == S.base )

{

printf( "动态空间分配失败\n" );

return ERROR;

}

S.top = S.base;

S.stacksize = STACK_INIT_SIZE;

return OK;

}

//向栈中压入一个元素

Status Push( SqStack & S, Elemtype val)

{

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

{

//如果存储空间已满，就需要增加新的空间

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

if( NULL == S.base )

{

printf( "动态空间分配失败\n" );

return ERROR;

}

/*

重新设定栈顶指针top，因为之前top指向的是一个不属于自己的空间，

现在新开辟了一个属于自己的空间，所以重新指定一下

万一地址换了也是有可能的！

*/

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

//修改结构体中，空间的总大小

S.stacksize = S.stacksize + STACKINCREMENT;

}

*S.top = val;

S.top++;

return OK;

}

//遍历整个栈

Status StackTraverse( SqStack & S )

{

if( S.top == S.base )

{

return ERROR;

}

else

{

Elemtype * p = S.base;

while( p != S.top )

{

printf( "%c ", *p );

p++;

}

printf( "\n" );

return OK;

}

}

//判断这个栈是否为空

bool StackEmtpy( SqStack & S )

{

if( S.top == S.base )

{

return true;

}

else

{

return false;

}

}

//返回这个栈的长度

int StackLength( SqStack & S )

{

return S.top - S.base;

}

//返回栈顶元素

Status GetTop( SqStack & S, Elemtype & c )

{

if( S.top == S.base )

{

return ERROR;

}

else

{

c = *(S.top-1);

}

}

//弹出一个元素，并且返回弹出元素的值

Status Pop( SqStack & S, Elemtype & c )

{

if( S.top == S.base )

{

return ERROR;

}

else

{

c = *(S.top-1);

S.top--;

S.stacksize--;

}

}

//清空这个栈

Status ClearStack( SqStack & S )

{

S.top = S.base;

return OK;

}

//销毁这个栈

Status DestroyStack( SqStack & S )

{

//释放栈空间

free( S.base );

//初始化栈结构体

S.top  = NULL;

S.base = NULL;

S.stacksize = 0;

return OK;

}

/*

题目要求的函数

题目貌似没有说是从上往下遍历，还是从下往上遍历

*/

void Pop_Print_Sq( SqStack & S )

{

while( S.top != S.base )

{

S.top--;

printf( "%c ", *S.top );

}

}

int main( void )

{

char c;

//创建一个栈

SqStack STA;

//初始化这个栈

InitStack( STA );

//为栈中压入一个元素

Push( STA, 'a' );

Push( STA, 'b' );

Push( STA, 'c' );

Push( STA, 'd' );

Push( STA, 'e' );

Push( STA, 'f' );

Push( STA, 'g' );

Push( STA, 'h' );

Push( STA, 'i' );

Push( STA, 'j' );

Push( STA, 'k' );

//遍历这个栈

printf( "压入元素从a~k，遍历这个栈：\n" );

StackTraverse( STA );

printf( "判断这个栈是否为空？" );

if( StackEmtpy( STA ) )

{

printf( "这个栈为空\n" );

}

else

{

printf( "这个栈不为空\n" );

}

printf( "该链表的长度为：%d\n", StackLength( STA ) );

GetTop( STA, c );

printf( "目前栈顶元素为：%c\n", c );

Pop( STA, c );

printf( "弹出的栈顶元素为：%c\n此刻的栈中元素是：", c );

StackTraverse( STA );

//题目要求的函数

printf( "依次弹出栈中元素、并将栈清空：\n" );

Pop_Print_Sq( STA );

StackTraverse( STA );

printf( "\n" );

//清空这个栈

ClearStack( STA );

StackTraverse( STA );

//销毁这个栈

DestroyStack( STA );

return 0;

}

/*

VC++6.0输出的结果是

========================================

压入元素从a~k，遍历这个栈：

a b c d e f g h i j k

判断这个栈是否为空？这个栈不为空

该链表的长度为：11

目前栈顶元素为：k

弹出的栈顶元素为：k

此刻的栈中元素是：a b c d e f g h i j

依次弹出栈中元素、并将栈清空：

j i h g f e d c b a

========================================

总结：

整体上没有什么难度，之前写过链表的栈，趁着这个机会把顺序栈也

练习一下。在malloc那里有点迷糊了，由于字数比较多，就在下面单独

总结吧。

*/