C语言 java 实现 数据结构栈的顺序存储

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

#define StackSize 100
typedef char DataType;
typedef struct {
    DataType data[StackSize];
    int top;
}SeqStack;

SeqStack s;

//置空栈
void InitStack(SeqStack *s) {
    s->top = -1;
}

//判栈空
int StackEmpty(SeqStack* s) {

    return s->top == -1;
}

//判栈满
int StackFull(SeqStack* s) {

    return s->top == StackSize-1;
}

//入栈
void Push(SeqStack* s,DataType x) {
    if (StackFull(s)){
        printf("stack overflow");
        exit(0);
    }else{
        s->data[++s->top] = x;
    }
}

//退栈
DataType Pop(SeqStack* s) {
    if (StackEmpty(s)){
        printf("stack underflow");
        exit(0);
    }else{
        return s->data[s->top--];
    }
}

应用

//圆括号检验
int Expr() {
    SeqStack S;
    DataType ch, x;
    InitStack(&S);
    ch = getchar();
    while (ch != '\n') {
        if (ch == '(') {
            Push(&S,ch);
        }else{
            if (ch == ')') {
                if (StackEmpty(&S)){
                    return 0;
                }else {
                    Pop(&S);
                }
        
            }
        }

        ch = getchar();
    }
    if (StackEmpty(&S)){
        return 1;
    }else {
        return 0;
    }

}
//字符串回文判断
int symmetry(char str[],int size) {
    SeqStack S;
    int j, k, i = 0;
    InitStack(&S);
    i = 8;
    for (j = 0; j < i / 2;j++) {
        Push(&S, str[j]);
    }
    k = (i + 1) / 2;
    for (j = k; j < i;j++) {
        if (str[j] != Pop(&S)) {
            return 0;
        }
    }
    return 1;
}
//数制转换
void conversion(int N,int d) {
    SeqStack S;
    InitStack(&S);
    while (N) {
        Push(&S, N % d);
        N = N / d;
    }
    while (!StackEmpty(&S)) {
        printf("%d", Pop(&S));
    }

}

int main() {

    //圆括号匹配检验
    /*if (Expr()==1) {
        printf("圆括号匹配");
    }else{
        printf("圆括号不匹配");
    }*/
    /*char str[8] = { 'a','b','a','b','b','a','b','a' };
    if (symmetry(str,8) ==1) {
        printf("是字符串回文");
    }else{
        printf("不是字符串回文");
    }*/

    //数制转换

    conversion(1348, 8);
    
    
}

 

 

 

################java 版

package stack;

import java.util.Scanner;

/**
 * @Date: 2021/1/27 11:32
 */
public class Stack {
    public static Integer stackSize = 100;
    private Object data[] = new Object[stackSize];
    private Integer top;

    public Stack() {
        this.top = -1;
    }

    public Object[] getData() {
        return data;
    }

    public void setData(Object[] data) {
        this.data = data;
    }

    public Integer getTop() {
        return top;
    }

    public void setTop(Integer top) {
        this.top = top;
    }


    //置空栈
    public void initStack(Stack stack) {
        stack.setTop(-1);
    }

    //判栈空
    public boolean stackEmpty(Stack stack) {
        return stack.getTop() == -1;
    }

    //判栈满
    public boolean stackFull(Stack stack) {
        return stack.getTop() == stackSize - 1;
    }

    //入栈
    public void push(Stack stack, Object object) throws Exception {
        if (stackFull(stack)) {
            throw new Exception("stock overflow");
        }
        Integer top = getTop();
        stack.data[++top] = object;
        stack.setTop(top);
    }

    public Object pop(Stack stack) throws Exception {
        if (stackEmpty(stack)) {
            throw new Exception("stock underflow");
        }
        Integer top = getTop();
        Object object = stack.data[top];
        stack.setTop(--top);
        return object;
    }

    public Object getTop(Stack stack)throws Exception{
        if (stackEmpty(stack)) {
            throw new Exception("stock underflow");
        }
        return stack.data[top];
    }

    public int expr() throws Exception {
        Stack stack = new Stack();
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String[] c = str.split("");
        for (String s : c) {
            if (s.equals("(")) {
                stack.push(stack, s);
            } else {
                if (s.equals(")")) {
                    if (stackEmpty(stack)) {
                        return 0;
                    } else {
                        stack.pop(stack);
                    }
                }
            }
        }
        if (stackEmpty(stack)) {
            return 1;
        }
        return 0;
    }

    //判断字符串字符串对称
    public int symmetry(Stack stack ,String[] str) throws Exception {
        int size = 0;
        for(String d:str){
            ++size;
        }

        int i = 0;
        for (i = 0; i < size / 2; i++) {
            stack.push(stack, str[i]);
        }
        if (size % 2 != 0) {
            i++;
        }
        while (!pop(stack).equals(str[i++])){
            return 0;
        }
        return 1;
    }

    //数制转换
    public void conversion(Stack stack, int num, int d) throws Exception {
        while (num >=d) {
            stack.push(stack, num % d);
            num = num / d;
        }
        stack.push(stack, num );
    }


    public static void main(String[] args) throws Exception {
        Stack stack = new Stack();
        stack.conversion(stack,1348,8);



       /* String[] str = {"a", "b", "c","e","b", "a"};
        int a = stack.symmetry(stack, str);
        if (a == 1){
            System.out.println("对称");
        }else {
            System.out.println("不对称");
        }*/
    }

}