【代码】顺序栈

发表于 更新于 阅读次数：

前言

顺序栈的Java实现

源代码

  • 基本类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package stack;
// 顺序栈
public class Stack {
    // 属性
    private int date[];
    private int top;
    private int Size = 50;
    // 方法
    // 构造方法：生成实力话对象时自动调用的方法，一般可以用它来完成初始化操作
    public Stack() {
        date = new int[Size];
        top = -1;
    }
    public int[] getDate() {
        return date;
    }
    public void setDate(int[] date) {
        this.date = date;
    }
    public int getTop() {
        return top;
    }
    public void setTop(int top) {
        this.top = top;
    }
    public int getSize() {
        return Size;
    }
    public void setSize(int size) {
        Size = size;
    }
    
    
    
}
  • 基本操作类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package stack;
// 栈的基本操作
public class StackAlgorithm {
    // (1)初始化栈：Init_Stack()
    
    // (2)判断栈是否为空：IsNull_Stack()
    public boolean stack_IsNull(Stack S) {
        boolean f = false;
        if(S.getTop()==-1) {
            f = true;
        }
        return f;
    }
    // (3)取栈顶元素顶值：GetTop_Stack()
    public int stack_GetTop(Stack S) {
        return S.getDate()[S.getTop()];
    }
    // (4)入栈：Push_Stack(x)
    public void stack_Push(Stack S, int x) {
        S.getDate()[S.getTop()+1] = x;
        S.setTop(S.getTop()+1);
    }
    // (5)出栈：Pop_Stack()
    public void stack_Pop(Stack S) {
        S.setTop(S.getTop()-1);
    }
    // (6)判断栈是否为满：IsFull_Stack()
    public boolean stack_IsFull(Stack S) {
        boolean f = false;
        if(S.getTop()==S.getSize()-1) {
            f = true;
        }
        return f;
    }
    
}
  • 菜单类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package stack;

public class StackMenu {
    void display() {
    System.out.printf("|---------------------------------------------------------------------|\n");
    System.out.printf("|------------栈的相关操作----------------------------------------------|\n");
    System.out.printf("|---------------------------------------------------------------------|\n");
    System.out.printf("|-----------1.入栈----------------------------------------------------|\n");                 
    System.out.printf("|-----------2.出栈 ---------------------------------------------------|\n");    
    System.out.printf("|-----------3.取栈顶元素的值-------------------------------------------|\n");
    System.out.printf("|-----------4.十进制转换为其它进制（二、八、十六）-----------------------|\n");
    System.out.printf("|-----------5.字符逆序------------------------------------------------|\n");
    System.out.printf("|-----------6.括号匹配------------------------------------------------|\n");
    System.out.printf("|-----------7.非递归表达式计算-----------------------------------------|\n");
    System.out.printf("|-----------8.表达式计算----------------------------------------------|\n");
    System.out.printf("|-----------0.退出---------------------------------------------------|\n");
    System.out.printf("|--------------------------------------------------------------------|\n");
    System.out.printf("|--------------------------------------------------------------------|\n");
    System.out.printf("          （谢谢使用本软件）\n");
    System.out.printf("请选择菜单中操作所对应的编号（1~7，0退出）：\n");

    }
    void chang() { 

        System.out.printf("|-------------------------------------------------------------------|\n");
        System.out.printf("|-------------------  a.十进制转二进制   ----------------------------|\n");
        System.out.printf("|-------------------  b.十进制转八进制   ----------------------------|\n");
        System.out.printf("|-------------------  c.十进制转十六进制 ----------------------------|\n");
        System.out.printf("|------------------------------------------------------------------|\n");

    }
}
  • 解决实际问题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package stack;

import java.util.Scanner;

public class StackTest {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        // 自动调用构造方法,通过构造方法就可以实现初始化
        Stack S = new Stack();
        StackMenu M = new StackMenu();
        StackAlgorithm A = new StackAlgorithm();
        M.display();
        while(true) {
            int N;
            System.out.println("请输入您要选择的操作序号：");
            N = sc.nextInt();
            switch(N) {
            case 1:
                // 循环入栈
                int x;
                System.out.println("请输入一个数据（以0结束）：");
                x = sc.nextInt();
                while(x!=0) {
                    if(A.stack_IsFull(S)!=true) {
                        A.stack_Push(S, x);
                    }else {
                        break;
                    }
                    System.out.println("请输入一个数据（以0结束）：");
                    x = sc.nextInt();
                }
                break;
            case 2:
                // 出栈一次
                int t = A.stack_GetTop(S);
                A.stack_Pop(S);
                System.out.println("出栈结果为："+t);
                break;
            case 4:
                // 十进制转成其他进制
                System.out.println("请输入你要转换的进制数（2，8，16）：");
                int m = sc.nextInt();
                System.out.println("请输入一个十进制数据：");
                x = sc.nextInt();
                // x对m进行求余入栈对基本操作
                while(x>0) {
                    // 求余
                    t = x%m;
                    // 入栈
                    A.stack_Push(S, t);
                    // x缩小
                    x = x/m;
                }
                // 直接出栈就可以实现倒计数
                while(A.stack_IsNull(S)!=true) {
                    // 取栈顶元素的值
                    t = A.stack_GetTop(S);
                    if(t<10) {
                        System.out.print(t);
                    }else {
                        switch(t) {
                        case 10:
                            System.out.print("A");
                            break;
                        case 11:
                            System.out.print("B");
                            break;
                        case 12:
                            System.out.print("C");
                            break;
                        case 13:
                            System.out.print("D");
                            break;
                        case 14:
                            System.out.print("E");
                            break;
                        case 15:
                            System.out.print("F");
                            break;
                        default:
                            return;
                        }
                    }
                    // 出栈
                    A.stack_Pop(S);
                }
                System.out.println();
                break;
            case 6:
                while(!A.stack_IsNull(S)) {
                    A.stack_Pop(S);
                }
                // 括号匹配
                System.out.println("请连续输入字符序列，以#结束：");
                char c = (char)System.in.read();
                boolean key = true;
                while(c!='#') {
                    // 如果输入的是左半个，就入栈，否则就出栈
                    // 判断是左还是右
                    if(c=='(') {
                        A.stack_Push(S, c);
                    }else if(c==')') {
                        if(!A.stack_IsNull(S)) {
                            A.stack_Pop(S);
                        }else {
                            key = false;
                        }
                    }
                    c = (char)System.in.read();
                }
                // 输入结束后
                if(A.stack_IsNull(S) ) {
                    if(key) {
                        System.out.println("匹配！");
                    }else {
                        System.out.println("不匹配！");
                    }
                }else if(!A.stack_IsNull(S)) {
                    System.out.println("不匹配！");
                }
                break;
            default:
                return;
            }
        }
    }
}

完成