数据结构复习代码——栈的顺序实现下的相关应用

1、利用顺序栈实现进制的转换（该节代码文件类型均为.cpp）

#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#include<stdlib.h>
#include<iostream>

#define ElemType int
#define STACK_INIT_SIZE 10
#define STACK_INC_SIZE 3
typedef struct SeqStack
{
    ElemType *base;     //每个节点的数据域
    int capacity;       //当前栈容量
    int top;            //栈顶指针
}SeqStack;

//初始化栈
void InitStack(SeqStack *s)
{
    s->base = (ElemType*)malloc(sizeof(ElemType)*STACK_INIT_SIZE);  //为栈分配内存空间并赋值给首址
    assert(s->base != NULL);        //判断内存空间是否分配成功
    s->capacity = STACK_INIT_SIZE;  //栈最大空间初始化赋值给最大容量
    s->top = 0;                     //栈顶指针赋值，指向0
}
//辅助函数--判空操作
int IsEmpty(SeqStack *s)
{
    if(s->top == 0)
    {
        return 1;
    }else{
        return 0;
    }
}
//辅助函数--判满操作
int IsFull(SeqStack *s)
{
    if(s->top == s->capacity)
    {
        return 1;
    }else{
        return 0;
    }
}
//辅助函数--遍历栈
void Show(SeqStack *s)
{
    for(int i=s->top-1;i>=0;i--)
    {
        printf("%d \n",s->base[i]);
    }
}
//辅助函数--获取栈顶元素
int GetElem(SeqStack *s,ElemType *e)
{
    if(!IsEmpty){
        printf("该栈已空！！");
        return 0;
    }
    int i = s->base[s->top-1];
    //e = s->base[s->top-1];
    return i;
}
//辅助函数--获取当前栈的长度
int Length(SeqStack *s){
    //由于该栈定义时，栈顶指针是从0开始的，即当前栈的长度为栈顶指针所指
    return s->top;
}
//辅助操作--增加栈内存空间
int Inc(SeqStack *s)
{
    //使用realloc函数为s->base分配新的内存空间
    ElemType *newbase = (ElemType*)realloc(s->base,sizeof(ElemType)*(s->capacity+STACK_INC_SIZE));
    //此磁盘中已无内存空间可分配给次栈
    if(newbase == NULL)
    {
        printf("内存空间已满！无法再次申请空间！");
        return 0;
    }
    //将新分配的内存空间首址赋值给栈
    s->base = newbase;
    //扩大该栈的最大容量
    s->capacity += STACK_INC_SIZE;
    return 1;
}
//入栈操作
void Push(SeqStack *s,ElemType e)
{
    if(IsFull(s)&& !Inc(s))
    {
        printf("栈空间已满，不能入栈！！");
        return;
    }
    s->base[s->top] = e;
    s->top++;
}

//出栈操作
void Pop(SeqStack *s)
{
    if(IsEmpty(s)){
        printf("栈已空，无元素可出栈！！");
        return;
    }
    --s->top;
    //printf("出栈元素为：%d \n",s->base[s->top]);
}
//清除栈操作
void Clear(SeqStack *s)
{
    //关于清除栈操作，只需将栈顶指针归零即可
    //因为该栈内的相关元素已无实用价值，可以任意改变
    s->top = 0;
}
//摧毁栈操作
void Destroy(SeqStack *s)
{
    //摧毁栈，需要释放已分配该栈的内存空间
    free(s->base);
    s->base=NULL;
    s->capacity = s->top = 0;
}
//利用栈的结构实现10进制到8进制的转换
void Convert_8(int value)
{
    SeqStack st;
    int v;
    InitStack(&st);
    while(value)
    {
        Push(&st,value%8);          //将操作数对8取余，并将结果入栈
        value = value /8;           //获取下一个操作数
    }
    //Show(&st);                      //结果显示
    //for(int i=st.top-1;i>=0;i--)
    //{
    //    printf("%d",st.base[i]);
    //}
    while(!IsEmpty(&st))
    {
        v=GetElem(&st,&v);
        Pop(&st);
        printf("%d",v);
    }
    printf("\n");
}

int main()
{
    int value = 47183;
    Convert_8(value);
    return 0;
}

2、利用顺序栈实现括号匹配问题

#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#include<stdlib.h>

#define ElemType char
#define STACK_INIT_SIZE 8
#define STACK_INC_SIZE 3
typedef struct SeqStack
{
    ElemType *base;     //每个节点的数据域
    int capacity;       //当前栈容量
    int top;            //栈顶指针
}SeqStack;

//初始化栈
void InitStack(SeqStack *s)
{
    s->base = (ElemType*)malloc(sizeof(ElemType)*STACK_INIT_SIZE);  //为栈分配内存空间并赋值给首址
    assert(s->base != NULL);        //判断内存空间是否分配成功
    s->capacity = STACK_INIT_SIZE;  //栈最大空间初始化赋值给最大容量
    s->top = 0;                     //栈顶指针赋值，指向0
}
//辅助函数--判空操作
bool IsEmpty(SeqStack *s)
{
    if(s->top == 0)
    {
        return true;
    }else{
        return false;
    }
}
//辅助函数--判满操作
int IsFull(SeqStack *s)
{
    if(s->top == s->capacity)
    {
        return 1;
    }else{
        return 0;
    }
}
//辅助函数--遍历栈
void Show(SeqStack *s)
{
    for(int i=s->top-1;i>=0;i--)
    {
        printf("%d \n",s->base[i]);
    }
}
//辅助函数--获取栈顶元素
ElemType GetElem(SeqStack *s,ElemType *e)
{
    if(!IsEmpty){
        printf("该栈已空！！");
        return 0;
    }
    ElemType i = s->base[s->top-1];
    //e = s->base[s->top-1];
    return i;
}
//辅助函数--获取当前栈的长度
int Length(SeqStack *s){
    //由于该栈定义时，栈顶指针是从0开始的，即当前栈的长度为栈顶指针所指
    return s->top;
}
//辅助操作--增加栈内存空间
int Inc(SeqStack *s)
{
    //使用realloc函数为s->base分配新的内存空间
    ElemType *newbase = (ElemType*)realloc(s->base,sizeof(ElemType)*(s->capacity+STACK_INC_SIZE));
    //此磁盘中已无内存空间可分配给次栈
    if(newbase == NULL)
    {
        printf("内存空间已满！无法再次申请空间！");
        return 0;
    }
    //将新分配的内存空间首址赋值给栈
    s->base = newbase;
    //扩大该栈的最大容量
    s->capacity += STACK_INC_SIZE;
    return 1;
}
//入栈操作
void Push(SeqStack *s,ElemType e)
{
    if(IsFull(s)&& !Inc(s))
    {
        printf("栈空间已满，不能入栈！！");
        return;
    }
    s->base[s->top] = e;
    s->top++;
}

//出栈操作
void Pop(SeqStack *s)
{
    if(IsEmpty(s)){
        printf("栈已空，无元素可出栈！！");
        return;
    }
    --s->top;
    //printf("出栈元素为：%d \n",s->base[s->top]);
}
//清除栈操作
void Clear(SeqStack *s)
{
    //关于清除栈操作，只需将栈顶指针归零即可
    //因为该栈内的相关元素已无实用价值，可以任意改变
    s->top = 0;
}
//摧毁栈操作
void Destroy(SeqStack *s)
{
    //摧毁栈，需要释放已分配该栈的内存空间
    free(s->base);
    s->base=NULL;
    s->capacity = s->top = 0;
}

bool Check(char *str)
{
    SeqStack st;
    InitStack(&st);
    char v;
    while(*str != '\0')
    {
        if(*str == '[' || *str == '(')
        {
            Push(&st,*str);
        }
        else if(*str == ']')
        {
            v = GetElem(&st,&v);
            if(v != '[')
                 return false;
            Pop(&st);

        }
        else if(*str == ')')
        {
            v = GetElem(&st,&v);
            if(v != '(')
                return false;
            Pop(&st);
        }
        ++str;
    }
    return IsEmpty(&st);
}

int main()
{
    char *str = "[([][])]";
    bool flag = Check(str);
    if(flag)
    {
        printf("OK!\n");
    }
    else{
        printf("Error!\n");
    }
    return 0;
}